From b0d3267ededcd479fa6f799778b0e92d8aa8bb50 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Sat, 11 Oct 2025 23:27:00 +0200 Subject: [PATCH 01/21] added builded ananas v1.0 --- dist/debug.d.ts | 182 + dist/debug.js | 372 + dist/debug.wasm | Bin 0 -> 186138 bytes dist/debug.wasm.map | 1 + dist/debug.wat | 45256 +++++++++++++++++++++++++++++++++++++++ dist/release.d.ts | 182 + dist/release.js | 372 + dist/release.wasm | Bin 0 -> 93361 bytes dist/release.wasm.map | 1 + dist/release.wat | 36780 ++++++++++++++++++++++++++++++++ dist/test.d.ts | 6 + dist/test.js | 47 + dist/test.wasm | Bin 0 -> 189597 bytes dist/test.wasm.map | 1 + dist/test.wat | 45369 ++++++++++++++++++++++++++++++++++++++++ 15 files changed, 128569 insertions(+) create mode 100644 dist/debug.d.ts create mode 100644 dist/debug.js create mode 100644 dist/debug.wasm create mode 100644 dist/debug.wasm.map create mode 100644 dist/debug.wat create mode 100644 dist/release.d.ts create mode 100644 dist/release.js create mode 100644 dist/release.wasm create mode 100644 dist/release.wasm.map create mode 100644 dist/release.wat create mode 100644 dist/test.d.ts create mode 100644 dist/test.js create mode 100644 dist/test.wasm create mode 100644 dist/test.wasm.map create mode 100644 dist/test.wat diff --git a/dist/debug.d.ts b/dist/debug.d.ts new file mode 100644 index 0000000..97c330c --- /dev/null +++ b/dist/debug.d.ts @@ -0,0 +1,182 @@ +/** Exported memory */ +export declare const memory: WebAssembly.Memory; +/** assembly/index/InputKind */ +export declare enum InputKind { + /** @type `i32` */ + Generic, + /** @type `i32` */ + SPI, +} +/** assembly/index/HasMetadata */ +export declare enum HasMetadata { + /** @type `i32` */ + Yes, + /** @type `i32` */ + No, +} +/** + * assembly/index/disassemble + * @param input `~lib/array/Array` + * @param kind `i32` + * @param withMetadata `i32` + * @returns `~lib/string/String` + */ +export declare function disassemble(input: Array, kind: number, withMetadata: number): string; +/** + * assembly/index/runProgram + * @param input `~lib/array/Array` + * @param registers `~lib/array/Array` + * @param kind `i32` + * @returns `assembly/api-generic/VmOutput` + */ +export declare function runProgram(input: Array, registers: Array, kind: number): __Record44; +/** + * assembly/api-generic/runVm + * @param input `assembly/api-generic/VmInput` + * @param logs `bool` + * @param useSbrkGas `bool` + * @returns `assembly/api-generic/VmOutput` + */ +export declare function runVm(input: __Record47, logs?: boolean, useSbrkGas?: boolean): __Record44; +/** + * assembly/api-generic/getAssembly + * @param p `assembly/program/Program` + * @returns `~lib/string/String` + */ +export declare function getAssembly(p: __Internref30): string; +/** + * assembly/program-build/wrapAsProgram + * @param bytecode `~lib/typedarray/Uint8Array` + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array; +/** + * assembly/api/resetGeneric + * @param program `~lib/array/Array` + * @param flatRegisters `~lib/array/Array` + * @param initialGas `i64` + */ +export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint): void; +/** + * assembly/api/resetGenericWithMemory + * @param program `~lib/array/Array` + * @param flatRegisters `~lib/array/Array` + * @param pageMap `~lib/typedarray/Uint8Array` + * @param chunks `~lib/typedarray/Uint8Array` + * @param initialGas `i64` + */ +export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint): void; +/** + * assembly/api/nextStep + * @returns `bool` + */ +export declare function nextStep(): boolean; +/** + * assembly/api/nSteps + * @param steps `u32` + * @returns `bool` + */ +export declare function nSteps(steps: number): boolean; +/** + * assembly/api/getProgramCounter + * @returns `u32` + */ +export declare function getProgramCounter(): number; +/** + * assembly/api/setNextProgramCounter + * @param pc `u32` + */ +export declare function setNextProgramCounter(pc: number): void; +/** + * assembly/api/getStatus + * @returns `u8` + */ +export declare function getStatus(): number; +/** + * assembly/api/getExitArg + * @returns `u32` + */ +export declare function getExitArg(): number; +/** + * assembly/api/getGasLeft + * @returns `i64` + */ +export declare function getGasLeft(): bigint; +/** + * assembly/api/setGasLeft + * @param gas `i64` + */ +export declare function setGasLeft(gas: bigint): void; +/** + * assembly/api/getRegisters + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function getRegisters(): Uint8Array; +/** + * assembly/api/setRegisters + * @param flatRegisters `~lib/array/Array` + */ +export declare function setRegisters(flatRegisters: Array): void; +/** + * assembly/api/getPageDump + * @param index `u32` + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function getPageDump(index: number): Uint8Array; +/** + * assembly/api/setMemory + * @param address `u32` + * @param data `~lib/typedarray/Uint8Array` + */ +export declare function setMemory(address: number, data: Uint8Array): void; +/** assembly/api-generic/InitialChunk */ +declare interface __Record45 { + /** @type `u32` */ + address: number | TOmittable; + /** @type `~lib/array/Array` */ + data: Array; +} +/** assembly/api-generic/VmOutput */ +declare interface __Record44 { + /** @type `i32` */ + status: number | TOmittable; + /** @type `~lib/array/Array` */ + registers: Array; + /** @type `u32` */ + pc: number | TOmittable; + /** @type `~lib/array/Array` */ + memory: Array<__Record45>; + /** @type `i64` */ + gas: bigint | TOmittable; + /** @type `u32` */ + exitCode: number | TOmittable; +} +/** assembly/api-generic/InitialPage */ +declare interface __Record48 { + /** @type `u32` */ + address: number | TOmittable; + /** @type `u32` */ + length: number | TOmittable; + /** @type `i32` */ + access: number | TOmittable; +} +/** assembly/api-generic/VmInput */ +declare interface __Record47 { + /** @type `~lib/array/Array` */ + registers: Array; + /** @type `u32` */ + pc: number | TOmittable; + /** @type `i64` */ + gas: bigint | TOmittable; + /** @type `~lib/array/Array` */ + program: Array; + /** @type `~lib/array/Array` */ + pageMap: Array<__Record48>; + /** @type `~lib/array/Array` */ + memory: Array<__Record45>; +} +/** assembly/program/Program */ +declare class __Internref30 extends Number { + private __nominal30: symbol; + private __nominal0: symbol; +} diff --git a/dist/debug.js b/dist/debug.js new file mode 100644 index 0000000..1fc85df --- /dev/null +++ b/dist/debug.js @@ -0,0 +1,372 @@ +async function instantiate(module, imports = {}) { + const adaptedImports = { + env: Object.setPrototypeOf({ + abort(message, fileName, lineNumber, columnNumber) { + // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void + message = __liftString(message >>> 0); + fileName = __liftString(fileName >>> 0); + lineNumber = lineNumber >>> 0; + columnNumber = columnNumber >>> 0; + (() => { + // @external.js + throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); + })(); + }, + "console.log"(text) { + // ~lib/bindings/dom/console.log(~lib/string/String) => void + text = __liftString(text >>> 0); + console.log(text); + }, + }, Object.assign(Object.create(globalThis), imports.env || {})), + }; + const { exports } = await WebAssembly.instantiate(module, adaptedImports); + const memory = exports.memory || imports.env.memory; + const adaptedExports = Object.setPrototypeOf({ + InputKind: (values => ( + // assembly/index/InputKind + values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", + values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", + values + ))({}), + HasMetadata: (values => ( + // assembly/index/HasMetadata + values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", + values[values.No = exports["HasMetadata.No"].valueOf()] = "No", + values + ))({}), + disassemble(input, kind, withMetadata) { + // assembly/index/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String + input = __lowerArray(__setU8, 27, 0, input) || __notnull(); + return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); + }, + runProgram(input, registers, kind) { + // assembly/index/runProgram(~lib/array/Array, ~lib/array/Array, i32) => assembly/api-generic/VmOutput + input = __retain(__lowerArray(__setU8, 27, 0, input) || __notnull()); + registers = __lowerArray(__setU64, 43, 3, registers) || __notnull(); + try { + return __liftRecord44(exports.runProgram(input, registers, kind) >>> 0); + } finally { + __release(input); + } + }, + runVm(input, logs, useSbrkGas) { + // assembly/api-generic/runVm(assembly/api-generic/VmInput, bool?, bool?) => assembly/api-generic/VmOutput + input = __lowerRecord47(input) || __notnull(); + logs = logs ? 1 : 0; + useSbrkGas = useSbrkGas ? 1 : 0; + exports.__setArgumentsLength(arguments.length); + return __liftRecord44(exports.runVm(input, logs, useSbrkGas) >>> 0); + }, + getAssembly(p) { + // assembly/api-generic/getAssembly(assembly/program/Program) => ~lib/string/String + p = __lowerInternref(p) || __notnull(); + return __liftString(exports.getAssembly(p) >>> 0); + }, + wrapAsProgram(bytecode) { + // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array + bytecode = __lowerTypedArray(Uint8Array, 5, 0, bytecode) || __notnull(); + return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0); + }, + resetGeneric(program, flatRegisters, initialGas) { + // assembly/api/resetGeneric(~lib/array/Array, ~lib/array/Array, i64) => void + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); + initialGas = initialGas || 0n; + try { + exports.resetGeneric(program, flatRegisters, initialGas); + } finally { + __release(program); + } + }, + resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas) { + // assembly/api/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64) => void + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + flatRegisters = __retain(__lowerArray(__setU8, 27, 0, flatRegisters) || __notnull()); + pageMap = __retain(__lowerTypedArray(Uint8Array, 5, 0, pageMap) || __notnull()); + chunks = __lowerTypedArray(Uint8Array, 5, 0, chunks) || __notnull(); + initialGas = initialGas || 0n; + try { + exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas); + } finally { + __release(program); + __release(flatRegisters); + __release(pageMap); + } + }, + nextStep() { + // assembly/api/nextStep() => bool + return exports.nextStep() != 0; + }, + nSteps(steps) { + // assembly/api/nSteps(u32) => bool + return exports.nSteps(steps) != 0; + }, + getProgramCounter() { + // assembly/api/getProgramCounter() => u32 + return exports.getProgramCounter() >>> 0; + }, + getExitArg() { + // assembly/api/getExitArg() => u32 + return exports.getExitArg() >>> 0; + }, + setGasLeft(gas) { + // assembly/api/setGasLeft(i64) => void + gas = gas || 0n; + exports.setGasLeft(gas); + }, + getRegisters() { + // assembly/api/getRegisters() => ~lib/typedarray/Uint8Array + return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); + }, + setRegisters(flatRegisters) { + // assembly/api/setRegisters(~lib/array/Array) => void + flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); + exports.setRegisters(flatRegisters); + }, + getPageDump(index) { + // assembly/api/getPageDump(u32) => ~lib/typedarray/Uint8Array + return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); + }, + setMemory(address, data) { + // assembly/api/setMemory(u32, ~lib/typedarray/Uint8Array) => void + data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); + exports.setMemory(address, data); + }, + }, exports); + function __liftRecord45(pointer) { + // assembly/api-generic/InitialChunk + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + address: __getU32(pointer + 0), + data: __liftArray(__getU8, 0, __getU32(pointer + 4)), + }; + } + function __liftRecord44(pointer) { + // assembly/api-generic/VmOutput + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + status: __getI32(pointer + 0), + registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), + pc: __getU32(pointer + 8), + memory: __liftArray(pointer => __liftRecord45(__getU32(pointer)), 2, __getU32(pointer + 12)), + gas: __getI64(pointer + 16), + exitCode: __getU32(pointer + 24), + }; + } + function __lowerRecord48(value) { + // assembly/api-generic/InitialPage + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(12, 48)); + __setU32(pointer + 0, value.address); + __setU32(pointer + 4, value.length); + __setU32(pointer + 8, value.access); + exports.__unpin(pointer); + return pointer; + } + function __lowerRecord45(value) { + // assembly/api-generic/InitialChunk + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(8, 45)); + __setU32(pointer + 0, value.address); + __setU32(pointer + 4, __lowerArray(__setU8, 27, 0, value.data) || __notnull()); + exports.__unpin(pointer); + return pointer; + } + function __lowerRecord47(value) { + // assembly/api-generic/VmInput + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(28, 47)); + __setU32(pointer + 0, __lowerArray(__setU64, 43, 3, value.registers) || __notnull()); + __setU32(pointer + 4, value.pc); + __setU64(pointer + 8, value.gas || 0n); + __setU32(pointer + 16, __lowerArray(__setU8, 27, 0, value.program) || __notnull()); + __setU32(pointer + 20, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, value.pageMap) || __notnull()); + __setU32(pointer + 24, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord45(value) || __notnull()); }, 46, 2, value.memory) || __notnull()); + exports.__unpin(pointer); + return pointer; + } + function __liftString(pointer) { + if (!pointer) return null; + const + end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, + memoryU16 = new Uint16Array(memory.buffer); + let + start = pointer >>> 1, + string = ""; + while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); + return string + String.fromCharCode(...memoryU16.subarray(start, end)); + } + function __liftArray(liftElement, align, pointer) { + if (!pointer) return null; + const + dataStart = __getU32(pointer + 4), + length = __dataview.getUint32(pointer + 12, true), + values = new Array(length); + for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0)); + return values; + } + function __lowerArray(lowerElement, id, align, values) { + if (values == null) return 0; + const + length = values.length, + buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, + header = exports.__pin(exports.__new(16, id)) >>> 0; + __setU32(header + 0, buffer); + __dataview.setUint32(header + 4, buffer, true); + __dataview.setUint32(header + 8, length << align, true); + __dataview.setUint32(header + 12, length, true); + for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]); + exports.__unpin(buffer); + exports.__unpin(header); + return header; + } + function __liftTypedArray(constructor, pointer) { + if (!pointer) return null; + return new constructor( + memory.buffer, + __getU32(pointer + 4), + __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT + ).slice(); + } + function __lowerTypedArray(constructor, id, align, values) { + if (values == null) return 0; + const + length = values.length, + buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, + header = exports.__new(12, id) >>> 0; + __setU32(header + 0, buffer); + __dataview.setUint32(header + 4, buffer, true); + __dataview.setUint32(header + 8, length << align, true); + new constructor(memory.buffer, buffer, length).set(values); + exports.__unpin(buffer); + return header; + } + class Internref extends Number {} + function __lowerInternref(value) { + if (value == null) return 0; + if (value instanceof Internref) return value.valueOf(); + throw TypeError("internref expected"); + } + const refcounts = new Map(); + function __retain(pointer) { + if (pointer) { + const refcount = refcounts.get(pointer); + if (refcount) refcounts.set(pointer, refcount + 1); + else refcounts.set(exports.__pin(pointer), 1); + } + return pointer; + } + function __release(pointer) { + if (pointer) { + const refcount = refcounts.get(pointer); + if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer); + else if (refcount) refcounts.set(pointer, refcount - 1); + else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`); + } + } + function __notnull() { + throw TypeError("value must not be null"); + } + let __dataview = new DataView(memory.buffer); + function __setU8(pointer, value) { + try { + __dataview.setUint8(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setUint8(pointer, value, true); + } + } + function __setU32(pointer, value) { + try { + __dataview.setUint32(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setUint32(pointer, value, true); + } + } + function __setU64(pointer, value) { + try { + __dataview.setBigUint64(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setBigUint64(pointer, value, true); + } + } + function __getU8(pointer) { + try { + return __dataview.getUint8(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getUint8(pointer, true); + } + } + function __getI32(pointer) { + try { + return __dataview.getInt32(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getInt32(pointer, true); + } + } + function __getU32(pointer) { + try { + return __dataview.getUint32(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getUint32(pointer, true); + } + } + function __getI64(pointer) { + try { + return __dataview.getBigInt64(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getBigInt64(pointer, true); + } + } + function __getU64(pointer) { + try { + return __dataview.getBigUint64(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getBigUint64(pointer, true); + } + } + return adaptedExports; +} +export const { + memory, + InputKind, + HasMetadata, + disassemble, + runProgram, + runVm, + getAssembly, + wrapAsProgram, + resetGeneric, + resetGenericWithMemory, + nextStep, + nSteps, + getProgramCounter, + setNextProgramCounter, + getStatus, + getExitArg, + getGasLeft, + setGasLeft, + getRegisters, + setRegisters, + getPageDump, + setMemory, +} = await (async url => instantiate( + await (async () => { + const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); + if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } + else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } + })(), { + } +))(new URL("debug.wasm", import.meta.url)); diff --git a/dist/debug.wasm b/dist/debug.wasm new file mode 100644 index 0000000000000000000000000000000000000000..3e089c857ddf44378c128c5cd641ae7fb6f281ee GIT binary patch literal 186138 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 aTef8Wlxa;psjlI^X{(a?!D)lZq5lJAL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/0a78010a7801?v=0.6.4 **/\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT = 12;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/24ee0024ee00?v=0.6.4 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const pageIdx = u32(currentAddress >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n const relAddress = currentAddress % PAGE_SIZE;\n const page = this.pages.get(pageIdx);\n const spaceInPage = PAGE_SIZE - relAddress;\n\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** https://graypaper.fluffylabs.dev/#/9a08063/2cc5022cc502?v=0.6.6 */\nexport function decodeSpi(data: Uint8Array): Program {\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const _heapPages = decoder.u16();\n const _stackSize = decoder.u24();\n\n const _roMem = decoder.bytes(roLength);\n const _rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n return deblob(code);\n}\n\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { RUN } from \"./instructions-exe\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, JumpTable, Program, ProgramCounter, decodeArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { InitialChunk, InitialPage, buildMemory } from \"./api-generic\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { VmInput, VmOutput, getAssembly, runVm } from \"./api-generic\";\nimport { deblob, decodeSpi, extractCodeAndMetadata, liftBytes } from \"./program\";\n\nexport * from \"./api\";\nexport { runVm, getAssembly } from \"./api-generic\";\nexport { wrapAsProgram } from \"./program-build\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n let program = liftBytes(input);\n let output = \"\";\n\n if (withMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(program);\n program = data.code;\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += data.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n if (kind === InputKind.Generic) {\n const p = deblob(program);\n return output + getAssembly(p);\n }\n\n if (kind === InputKind.SPI) {\n const p = decodeSpi(program);\n return output + getAssembly(p);\n }\n\n return `Unknown kind: ${kind}`;\n}\n\nexport function runProgram(input: u8[], registers: u64[], kind: InputKind): VmOutput {\n if (kind === InputKind.Generic) {\n const vmInput = new VmInput();\n vmInput.registers = registers;\n vmInput.gas = 10_000;\n vmInput.program = input;\n\n const output = runVm(vmInput, true);\n console.log(`Finished with status: ${output.status}`);\n return output;\n }\n\n if (kind === InputKind.SPI) {\n throw new Error(\"SPI running not supported yet\");\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { Program, deblob, decodeArguments, liftBytes, resolveArguments } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n registers: u64[] = new Array(NO_OF_REGISTERS).fill(0);\n pc: u32 = 0;\n gas: i64 = 0;\n program: u8[] = [];\n pageMap: InitialPage[] = [];\n memory: InitialChunk[] = [];\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const p = deblob(liftBytes(input.program));\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < registers.length; r++) {\n registers[r] = input.registers[r];\n }\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, input.pageMap, input.memory);\n\n const int = new Interpreter(p, registers, memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = p.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n return this.gas < 0;\n }\n}\n","import { Arguments, REQUIRED_BYTES, nibbles } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/dist/debug.wat b/dist/debug.wat new file mode 100644 index 0000000..cfbba47 --- /dev/null +++ b/dist/debug.wat @@ -0,0 +1,45256 @@ +(module + (type $0 (func (param i32) (result i32))) + (type $1 (func (param i32 i32))) + (type $2 (func (param i32 i32 i32) (result i32))) + (type $3 (func (param i32 i32) (result i32))) + (type $4 (func (param i32 i32 i32))) + (type $5 (func (param i32 i32 i32 i32) (result i32))) + (type $6 (func (param i32))) + (type $7 (func)) + (type $8 (func (param i32) (result i64))) + (type $9 (func (param i32 i64))) + (type $10 (func (result i32))) + (type $11 (func (param i64 i64) (result i64))) + (type $12 (func (param i64 i32) (result i32))) + (type $13 (func (param i32 i64) (result i32))) + (type $14 (func (param i64) (result i32))) + (type $15 (func (param i32 i32 i64))) + (type $16 (func (param i32 i32 i32 i32))) + (type $17 (func (param i64 i32 i32) (result i32))) + (type $18 (func (param i32 i32 i64) (result i32))) + (type $19 (func (param i32 i64 i32))) + (type $20 (func (param i32 i32) (result i64))) + (type $21 (func (param i32 i64 i32 i32) (result i32))) + (type $22 (func (param i32 i32 i32 i32 i64))) + (type $23 (func (param i32 i32 i64 i32) (result i32))) + (type $24 (func (param i64) (result i64))) + (type $25 (func (param i32 i32 i32 i32 i32))) + (type $26 (func (param i32 i64 i32 i32))) + (type $27 (func (param i32 i32 i64 i32 i32))) + (type $28 (func (param i32 i32 i32 i32 i32) (result i32))) + (type $29 (func (param i32 i32 i64 i32))) + (type $30 (func (result i64))) + (type $31 (func (param i64))) + (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) + (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) + (global $assembly/arguments/Arguments.Zero i32 (i32.const 0)) + (global $assembly/arguments/Arguments.OneImm i32 (i32.const 1)) + (global $assembly/arguments/Arguments.TwoImm i32 (i32.const 2)) + (global $assembly/arguments/Arguments.OneOff i32 (i32.const 3)) + (global $assembly/arguments/Arguments.OneRegOneImm i32 (i32.const 4)) + (global $assembly/arguments/Arguments.OneRegOneExtImm i32 (i32.const 5)) + (global $assembly/arguments/Arguments.OneRegTwoImm i32 (i32.const 6)) + (global $assembly/arguments/Arguments.OneRegOneImmOneOff i32 (i32.const 7)) + (global $assembly/arguments/Arguments.TwoReg i32 (i32.const 8)) + (global $assembly/arguments/Arguments.TwoRegOneImm i32 (i32.const 9)) + (global $assembly/arguments/Arguments.TwoRegOneOff i32 (i32.const 10)) + (global $assembly/arguments/Arguments.TwoRegTwoImm i32 (i32.const 11)) + (global $assembly/arguments/Arguments.ThreeReg i32 (i32.const 12)) + (global $assembly/arguments/RELEVANT_ARGS i32 (i32.const 112)) + (global $assembly/arguments/REQUIRED_BYTES i32 (i32.const 240)) + (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) + (global $~lib/shared/runtime/Runtime.Stub i32 (i32.const 0)) + (global $~lib/shared/runtime/Runtime.Minimal i32 (i32.const 1)) + (global $~lib/shared/runtime/Runtime.Incremental i32 (i32.const 2)) + (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) + (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) + (global $~lib/native/ASC_LOW_MEMORY_LIMIT i32 (i32.const 0)) + (global $~lib/builtins/i32.MAX_VALUE i32 (i32.const 2147483647)) + (global $~argumentsLength (mut i32) (i32.const 0)) + (global $assembly/arguments/DECODERS i32 (i32.const 1248)) + (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) + (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) + (global $~lib/native/ASC_RUNTIME i32 (i32.const 2)) + (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) + (global $assembly/registers/NO_OF_REGISTERS i32 (i32.const 13)) + (global $assembly/registers/REG_SIZE_BYTES i32 (i32.const 8)) + (global $assembly/memory-page/PAGE_SIZE i32 (i32.const 4096)) + (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) + (global $~lib/native/ASC_SHRINK_LEVEL i32 (i32.const 0)) + (global $assembly/memory-page/RESERVED_MEMORY (mut i32) (i32.const 0)) + (global $assembly/memory-page/RESERVED_PAGES (mut i32) (i32.const 0)) + (global $assembly/memory-page/ALLOCATE_EAGERLY (mut i32) (i32.const 0)) + (global $assembly/memory-page/Access.None i32 (i32.const 0)) + (global $assembly/memory-page/Access.Read i32 (i32.const 1)) + (global $assembly/memory-page/Access.Write i32 (i32.const 2)) + (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) + (global $assembly/memory/MEMORY_SIZE i64 (i64.const 4294967296)) + (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) + (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) + (global $assembly/instructions/outcome/Result.PANIC i32 (i32.const 0)) + (global $assembly/instructions/outcome/Result.FAULT i32 (i32.const 1)) + (global $assembly/instructions/outcome/Result.FAULT_ACCESS i32 (i32.const 2)) + (global $assembly/instructions/outcome/Result.HOST i32 (i32.const 3)) + (global $assembly/instructions/outcome/Outcome.Ok i32 (i32.const 0)) + (global $assembly/instructions/outcome/Outcome.StaticJump i32 (i32.const 1)) + (global $assembly/instructions/outcome/Outcome.DynamicJump i32 (i32.const 2)) + (global $assembly/instructions/outcome/Outcome.Result i32 (i32.const 3)) + (global $assembly/instructions/bit/count_set_bits_64 i32 (i32.const 8352)) + (global $assembly/instructions/bit/count_set_bits_32 i32 (i32.const 8384)) + (global $assembly/instructions/bit/leading_zero_bits_64 i32 (i32.const 8416)) + (global $assembly/instructions/bit/leading_zero_bits_32 i32 (i32.const 8448)) + (global $assembly/instructions/bit/trailing_zero_bits_64 i32 (i32.const 8480)) + (global $assembly/instructions/bit/trailing_zero_bits_32 i32 (i32.const 8512)) + (global $assembly/instructions/bit/sign_extend_8 i32 (i32.const 8544)) + (global $assembly/instructions/bit/sign_extend_16 i32 (i32.const 8576)) + (global $assembly/instructions/bit/zero_extend_16 i32 (i32.const 8608)) + (global $assembly/instructions/bit/reverse_bytes i32 (i32.const 8640)) + (global $assembly/instructions/branch/branch_eq_imm i32 (i32.const 8672)) + (global $assembly/instructions/branch/branch_ne_imm i32 (i32.const 8704)) + (global $assembly/instructions/branch/branch_lt_u_imm i32 (i32.const 8736)) + (global $assembly/instructions/branch/branch_le_u_imm i32 (i32.const 8768)) + (global $assembly/instructions/branch/branch_ge_u_imm i32 (i32.const 8800)) + (global $assembly/instructions/branch/branch_gt_u_imm i32 (i32.const 8832)) + (global $assembly/instructions/branch/branch_lt_s_imm i32 (i32.const 8864)) + (global $assembly/instructions/branch/branch_le_s_imm i32 (i32.const 8896)) + (global $assembly/instructions/branch/branch_ge_s_imm i32 (i32.const 8928)) + (global $assembly/instructions/branch/branch_gt_s_imm i32 (i32.const 8960)) + (global $assembly/instructions/branch/branch_eq i32 (i32.const 8992)) + (global $assembly/instructions/branch/branch_ne i32 (i32.const 9024)) + (global $assembly/instructions/branch/branch_lt_u i32 (i32.const 9056)) + (global $assembly/instructions/branch/branch_lt_s i32 (i32.const 9088)) + (global $assembly/instructions/branch/branch_ge_u i32 (i32.const 9120)) + (global $assembly/instructions/branch/branch_ge_s i32 (i32.const 9152)) + (global $assembly/instructions/jump/jump i32 (i32.const 9184)) + (global $assembly/instructions/jump/jump_ind i32 (i32.const 9216)) + (global $assembly/instructions/jump/load_imm_jump i32 (i32.const 9248)) + (global $assembly/instructions/jump/load_imm_jump_ind i32 (i32.const 9280)) + (global $assembly/instructions/load/load_imm_64 i32 (i32.const 9312)) + (global $assembly/instructions/load/load_imm i32 (i32.const 9344)) + (global $assembly/instructions/load/load_u8 i32 (i32.const 9696)) + (global $assembly/instructions/load/load_i8 i32 (i32.const 9728)) + (global $assembly/instructions/load/load_u16 i32 (i32.const 9760)) + (global $assembly/instructions/load/load_i16 i32 (i32.const 9792)) + (global $assembly/instructions/load/load_u32 i32 (i32.const 9824)) + (global $assembly/instructions/load/load_i32 i32 (i32.const 9856)) + (global $assembly/instructions/load/load_u64 i32 (i32.const 9888)) + (global $assembly/instructions/load/load_ind_u8 i32 (i32.const 9920)) + (global $assembly/instructions/load/load_ind_i8 i32 (i32.const 9952)) + (global $assembly/instructions/load/load_ind_u16 i32 (i32.const 9984)) + (global $assembly/instructions/load/load_ind_i16 i32 (i32.const 10016)) + (global $assembly/instructions/load/load_ind_u32 i32 (i32.const 10048)) + (global $assembly/instructions/load/load_ind_i32 i32 (i32.const 10080)) + (global $assembly/instructions/load/load_ind_u64 i32 (i32.const 10112)) + (global $assembly/instructions/logic/and_imm i32 (i32.const 10144)) + (global $assembly/instructions/logic/xor_imm i32 (i32.const 10176)) + (global $assembly/instructions/logic/or_imm i32 (i32.const 10208)) + (global $assembly/instructions/logic/and i32 (i32.const 10240)) + (global $assembly/instructions/logic/xor i32 (i32.const 10272)) + (global $assembly/instructions/logic/or i32 (i32.const 10304)) + (global $assembly/instructions/logic/and_inv i32 (i32.const 10336)) + (global $assembly/instructions/logic/or_inv i32 (i32.const 10368)) + (global $assembly/instructions/logic/xnor i32 (i32.const 10400)) + (global $assembly/instructions/math/add_imm_32 i32 (i32.const 10432)) + (global $assembly/instructions/math/mul_imm_32 i32 (i32.const 10464)) + (global $assembly/instructions/math/neg_add_imm_32 i32 (i32.const 10496)) + (global $assembly/instructions/math/add_imm i32 (i32.const 10528)) + (global $assembly/instructions/math/mul_imm i32 (i32.const 10560)) + (global $assembly/instructions/math/neg_add_imm i32 (i32.const 10592)) + (global $assembly/instructions/math/add_32 i32 (i32.const 10624)) + (global $assembly/instructions/math/sub_32 i32 (i32.const 10656)) + (global $assembly/instructions/math/mul_32 i32 (i32.const 10688)) + (global $~lib/builtins/u64.MAX_VALUE i64 (i64.const -1)) + (global $assembly/instructions/math/div_u_32 i32 (i32.const 10720)) + (global $~lib/builtins/i32.MIN_VALUE i32 (i32.const -2147483648)) + (global $assembly/instructions/math/div_s_32 i32 (i32.const 10752)) + (global $assembly/instructions/math/rem_u_32 i32 (i32.const 10784)) + (global $assembly/instructions/math/rem_s_32 i32 (i32.const 10816)) + (global $assembly/instructions/math/add_64 i32 (i32.const 10848)) + (global $assembly/instructions/math/sub i32 (i32.const 10880)) + (global $assembly/instructions/math/mul i32 (i32.const 10912)) + (global $assembly/instructions/math/div_u i32 (i32.const 10944)) + (global $~lib/builtins/i64.MIN_VALUE i64 (i64.const -9223372036854775808)) + (global $assembly/instructions/math/div_s i32 (i32.const 10976)) + (global $assembly/instructions/math/rem_u i32 (i32.const 11008)) + (global $assembly/instructions/math/rem_s i32 (i32.const 11040)) + (global $assembly/instructions/math/mul_upper_s_s i32 (i32.const 11072)) + (global $assembly/instructions/math/mul_upper_u_u i32 (i32.const 11104)) + (global $assembly/instructions/math/mul_upper_s_u i32 (i32.const 11136)) + (global $assembly/instructions/math/max i32 (i32.const 11168)) + (global $assembly/instructions/math/max_u i32 (i32.const 11200)) + (global $assembly/instructions/math/min i32 (i32.const 11232)) + (global $assembly/instructions/math/min_u i32 (i32.const 11264)) + (global $assembly/instructions/mov/move_reg i32 (i32.const 11296)) + (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11328)) + (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11360)) + (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11392)) + (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11424)) + (global $assembly/instructions/rot/rot_r_64_imm i32 (i32.const 11456)) + (global $assembly/instructions/rot/rot_r_64_imm_alt i32 (i32.const 11488)) + (global $assembly/instructions/rot/rot_r_32_imm i32 (i32.const 11520)) + (global $assembly/instructions/rot/rot_r_32_imm_alt i32 (i32.const 11552)) + (global $assembly/instructions/rot/rot_l_64 i32 (i32.const 11584)) + (global $assembly/instructions/rot/rot_l_32 i32 (i32.const 11616)) + (global $assembly/instructions/rot/rot_r_64 i32 (i32.const 11648)) + (global $assembly/instructions/rot/rot_r_32 i32 (i32.const 11680)) + (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 11712)) + (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 11744)) + (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 11776)) + (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 11808)) + (global $assembly/instructions/set/set_lt_u i32 (i32.const 11840)) + (global $assembly/instructions/set/set_lt_s i32 (i32.const 11872)) + (global $assembly/instructions/shift/MAX_SHIFT_64 i32 (i32.const 64)) + (global $assembly/instructions/shift/MAX_SHIFT_32 i32 (i32.const 32)) + (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 11904)) + (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 11936)) + (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 11968)) + (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 12000)) + (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 12032)) + (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 12064)) + (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 12096)) + (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 12128)) + (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 12160)) + (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 12192)) + (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 12224)) + (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 12256)) + (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 12288)) + (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 12320)) + (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12352)) + (global $assembly/instructions/shift/shlo_l i32 (i32.const 12384)) + (global $assembly/instructions/shift/shlo_r i32 (i32.const 12416)) + (global $assembly/instructions/shift/shar_r i32 (i32.const 12448)) + (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12480)) + (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12512)) + (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12544)) + (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12576)) + (global $assembly/instructions/store/store_u8 i32 (i32.const 12608)) + (global $assembly/instructions/store/store_u16 i32 (i32.const 12640)) + (global $assembly/instructions/store/store_u32 i32 (i32.const 12672)) + (global $assembly/instructions/store/store_u64 i32 (i32.const 12704)) + (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 12736)) + (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 12768)) + (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 12800)) + (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 12832)) + (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 12864)) + (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 12896)) + (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 12928)) + (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 12960)) + (global $assembly/instructions/misc/INVALID i32 (i32.const 12992)) + (global $assembly/instructions/misc/trap i32 (i32.const 13024)) + (global $assembly/instructions/misc/fallthrough i32 (i32.const 13056)) + (global $assembly/instructions/misc/ecalli i32 (i32.const 13088)) + (global $assembly/instructions/misc/sbrk i32 (i32.const 13264)) + (global $assembly/instructions-exe/RUN i32 (i32.const 14240)) + (global $assembly/codec/MASKS i32 (i32.const 14320)) + (global $assembly/codec/variableLength i32 (i32.const 14368)) + (global $assembly/program/MAX_SKIP i32 (i32.const 24)) + (global $assembly/program/BasicBlock.NONE i32 (i32.const 0)) + (global $assembly/program/BasicBlock.START i32 (i32.const 2)) + (global $assembly/program/BasicBlock.END i32 (i32.const 4)) + (global $assembly/interpreter/Status.OK i32 (i32.const -1)) + (global $assembly/interpreter/Status.HALT i32 (i32.const 0)) + (global $assembly/interpreter/Status.PANIC i32 (i32.const 1)) + (global $assembly/interpreter/Status.FAULT i32 (i32.const 2)) + (global $assembly/interpreter/Status.HOST i32 (i32.const 3)) + (global $assembly/interpreter/Status.OOG i32 (i32.const 4)) + (global $assembly/interpreter/DjumpStatus.OK i32 (i32.const 0)) + (global $assembly/interpreter/DjumpStatus.HALT i32 (i32.const 1)) + (global $assembly/interpreter/DjumpStatus.PANIC i32 (i32.const 2)) + (global $assembly/interpreter/EXIT i32 (i32.const -65536)) + (global $assembly/interpreter/JUMP_ALIGMENT_FACTOR i32 (i32.const 2)) + (global $assembly/interpreter/MAX_U32 (mut i64) (i64.const 0)) + (global $assembly/api/interpreter (mut i32) (i32.const 0)) + (global $assembly/index/InputKind.Generic i32 (i32.const 0)) + (global $assembly/index/InputKind.SPI i32 (i32.const 1)) + (global $assembly/index/HasMetadata.Yes i32 (i32.const 0)) + (global $assembly/index/HasMetadata.No i32 (i32.const 1)) + (global $~lib/builtins/u32.MAX_VALUE i32 (i32.const -1)) + (global $~lib/rt/__rtti_base i32 (i32.const 20032)) + (global $~lib/memory/__data_end i32 (i32.const 20276)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 53044)) + (global $~lib/memory/__heap_base i32 (i32.const 53044)) + (memory $0 1) + (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") + (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $2 (i32.const 140) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") + (data $3 (i32.const 220) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00\a0\00\00\00\a0\00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $4 (i32.const 268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e\00\00\00\00\00") + (data $5 (i32.const 332) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $6 (i32.const 400) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $7 (i32.const 432) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $8 (i32.const 460) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e\00\00\00\00\00\00\00\00\00") + (data $9 (i32.const 524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $10 (i32.const 576) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $11 (i32.const 604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $12 (i32.const 668) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00") + (data $13 (i32.const 700) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $14 (i32.const 764) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") + (data $15 (i32.const 796) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") + (data $16 (i32.const 828) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\04\00\00\00\00\00\00\00\00\00\00\00") + (data $17 (i32.const 860) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\05\00\00\00\00\00\00\00\00\00\00\00") + (data $18 (i32.const 892) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\06\00\00\00\00\00\00\00\00\00\00\00") + (data $19 (i32.const 924) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\07\00\00\00\00\00\00\00\00\00\00\00") + (data $20 (i32.const 956) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00") + (data $21 (i32.const 988) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\t\00\00\00\00\00\00\00\00\00\00\00") + (data $22 (i32.const 1020) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") + (data $23 (i32.const 1052) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0b\00\00\00\00\00\00\00\00\00\00\00") + (data $24 (i32.const 1084) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0c\00\00\00\00\00\00\00\00\00\00\00") + (data $25 (i32.const 1116) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00") + (data $26 (i32.const 1148) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\b0\02\00\00\10\03\00\000\03\00\00P\03\00\00p\03\00\00\90\03\00\00\b0\03\00\00\d0\03\00\00\f0\03\00\00\10\04\00\000\04\00\00P\04\00\00p\04\00\00\00\00\00\00\00\00\00\00") + (data $27 (i32.const 1228) ",\00\00\00\00\00\00\00\00\00\00\00\07\00\00\00\10\00\00\00\90\04\00\00\90\04\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $28 (i32.const 1276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $29 (i32.const 1324) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00S\00B\00R\00K\00\00\00\00\00") + (data $30 (i32.const 1356) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00T\00R\00A\00P\00\00\00\00\00") + (data $31 (i32.const 1388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H\00\00\00\00\00\00\00") + (data $32 (i32.const 1436) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I\00") + (data $33 (i32.const 1468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00") + (data $34 (i32.const 1516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008\00\00\00\00\00") + (data $35 (i32.const 1564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006\00\00\00") + (data $36 (i32.const 1612) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002\00\00\00") + (data $37 (i32.const 1660) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004\00\00\00") + (data $38 (i32.const 1708) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00J\00U\00M\00P\00\00\00\00\00") + (data $39 (i32.const 1740) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $40 (i32.const 1788) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $41 (i32.const 1836) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $42 (i32.const 1884) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $43 (i32.const 1932) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $44 (i32.const 1980) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $45 (i32.const 2028) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $46 (i32.const 2076) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $47 (i32.const 2124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $48 (i32.const 2172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $49 (i32.const 2220) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") + (data $50 (i32.const 2268) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $51 (i32.const 2316) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $52 (i32.const 2364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $53 (i32.const 2428) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") + (data $54 (i32.const 2492) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $55 (i32.const 2556) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $56 (i32.const 2620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00\00\00") + (data $57 (i32.const 2668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M\00\00\00") + (data $58 (i32.const 2716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M\00\00\00") + (data $59 (i32.const 2764) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $60 (i32.const 2828) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $61 (i32.const 2892) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $62 (i32.const 2956) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $63 (i32.const 3020) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $64 (i32.const 3084) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $65 (i32.const 3148) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $66 (i32.const 3212) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $67 (i32.const 3276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $68 (i32.const 3324) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $69 (i32.const 3388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $70 (i32.const 3452) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00") + (data $71 (i32.const 3516) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00") + (data $72 (i32.const 3580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00") + (data $73 (i32.const 3644) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00") + (data $74 (i32.const 3708) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008\00\00\00") + (data $75 (i32.const 3756) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") + (data $76 (i32.const 3804) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") + (data $77 (i32.const 3852) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S\00\00\00") + (data $78 (i32.const 3900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00") + (data $79 (i32.const 3948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006\00\00\00") + (data $80 (i32.const 3996) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002\00\00\00") + (data $81 (i32.const 4044) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004\00\00\00") + (data $82 (i32.const 4092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00") + (data $83 (i32.const 4140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008\00\00\00\00\00\00\00") + (data $84 (i32.const 4188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00") + (data $85 (i32.const 4236) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006\00\00\00\00\00") + (data $86 (i32.const 4284) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00") + (data $87 (i32.const 4332) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002\00\00\00\00\00") + (data $88 (i32.const 4380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00") + (data $89 (i32.const 4428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") + (data $90 (i32.const 4476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $91 (i32.const 4524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $92 (i32.const 4572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M\00") + (data $93 (i32.const 4604) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") + (data $94 (i32.const 4652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") + (data $95 (i32.const 4700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") + (data $96 (i32.const 4748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $97 (i32.const 4796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $98 (i32.const 4844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $99 (i32.const 4892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00") + (data $100 (i32.const 4940) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") + (data $101 (i32.const 4988) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") + (data $102 (i32.const 5036) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $103 (i32.const 5100) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $104 (i32.const 5164) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $105 (i32.const 5228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") + (data $106 (i32.const 5276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") + (data $107 (i32.const 5324) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") + (data $108 (i32.const 5372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") + (data $109 (i32.const 5420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $110 (i32.const 5468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $111 (i32.const 5516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $112 (i32.const 5564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00") + (data $113 (i32.const 5612) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $114 (i32.const 5676) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $115 (i32.const 5740) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $116 (i32.const 5804) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00\00\00\00\00") + (data $117 (i32.const 5852) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $118 (i32.const 5916) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00\00\00\00\00") + (data $119 (i32.const 5964) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $120 (i32.const 6028) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00\00\00\00\00\00\00\00\00\00\00") + (data $121 (i32.const 6076) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00\00\00\00\00\00\00\00\00\00\00") + (data $122 (i32.const 6124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00\00\00\00\00\00\00") + (data $123 (i32.const 6172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00\00\00\00\00\00\00") + (data $124 (i32.const 6220) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00\00\00\00\00\00\00") + (data $125 (i32.const 6268) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00\00\00\00\00\00\00") + (data $126 (i32.const 6316) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00") + (data $127 (i32.const 6380) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002\00") + (data $128 (i32.const 6412) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002\00") + (data $129 (i32.const 6444) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002\00") + (data $130 (i32.const 6476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $131 (i32.const 6524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $132 (i32.const 6572) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $133 (i32.const 6620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $134 (i32.const 6668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $135 (i32.const 6716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $136 (i32.const 6764) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $137 (i32.const 6812) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004\00") + (data $138 (i32.const 6844) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004\00") + (data $139 (i32.const 6876) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004\00") + (data $140 (i32.const 6908) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $141 (i32.const 6956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $142 (i32.const 7004) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $143 (i32.const 7052) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $144 (i32.const 7100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $145 (i32.const 7148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $146 (i32.const 7196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $147 (i32.const 7244) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00A\00N\00D\00\00\00\00\00\00\00") + (data $148 (i32.const 7276) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00X\00O\00R\00\00\00\00\00\00\00") + (data $149 (i32.const 7308) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00O\00R\00\00\00\00\00\00\00\00\00") + (data $150 (i32.const 7340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S\00\00\00") + (data $151 (i32.const 7388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U\00\00\00") + (data $152 (i32.const 7436) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U\00\00\00") + (data $153 (i32.const 7484) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $154 (i32.const 7532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $155 (i32.const 7580) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $156 (i32.const 7628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $157 (i32.const 7676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $158 (i32.const 7724) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $159 (i32.const 7772) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $160 (i32.const 7820) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $161 (i32.const 7868) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $162 (i32.const 7916) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V\00") + (data $163 (i32.const 7948) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00X\00N\00O\00R\00\00\00\00\00") + (data $164 (i32.const 7980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00A\00X\00\00\00\00\00\00\00") + (data $165 (i32.const 8012) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00A\00X\00_\00U\00\00\00") + (data $166 (i32.const 8044) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00I\00N\00\00\00\00\00\00\00") + (data $167 (i32.const 8076) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00I\00N\00_\00U\00\00\00") + (data $168 (i32.const 8108) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00") + (data $169 (i32.const 8156) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h\00") + (data $170 (i32.const 8204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") + (data $171 (i32.const 8268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00") + (data $172 (i32.const 8332) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\0e\00\00\00\00\00\00\00\00\00\00\00") + (data $173 (i32.const 8364) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\0f\00\00\00\00\00\00\00\00\00\00\00") + (data $174 (i32.const 8396) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\10\00\00\00\00\00\00\00\00\00\00\00") + (data $175 (i32.const 8428) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\11\00\00\00\00\00\00\00\00\00\00\00") + (data $176 (i32.const 8460) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\12\00\00\00\00\00\00\00\00\00\00\00") + (data $177 (i32.const 8492) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\13\00\00\00\00\00\00\00\00\00\00\00") + (data $178 (i32.const 8524) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\14\00\00\00\00\00\00\00\00\00\00\00") + (data $179 (i32.const 8556) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\15\00\00\00\00\00\00\00\00\00\00\00") + (data $180 (i32.const 8588) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\16\00\00\00\00\00\00\00\00\00\00\00") + (data $181 (i32.const 8620) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\17\00\00\00\00\00\00\00\00\00\00\00") + (data $182 (i32.const 8652) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\18\00\00\00\00\00\00\00\00\00\00\00") + (data $183 (i32.const 8684) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\19\00\00\00\00\00\00\00\00\00\00\00") + (data $184 (i32.const 8716) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1a\00\00\00\00\00\00\00\00\00\00\00") + (data $185 (i32.const 8748) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1b\00\00\00\00\00\00\00\00\00\00\00") + (data $186 (i32.const 8780) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1c\00\00\00\00\00\00\00\00\00\00\00") + (data $187 (i32.const 8812) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1d\00\00\00\00\00\00\00\00\00\00\00") + (data $188 (i32.const 8844) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1e\00\00\00\00\00\00\00\00\00\00\00") + (data $189 (i32.const 8876) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1f\00\00\00\00\00\00\00\00\00\00\00") + (data $190 (i32.const 8908) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $191 (i32.const 8940) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00!\00\00\00\00\00\00\00\00\00\00\00") + (data $192 (i32.const 8972) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\"\00\00\00\00\00\00\00\00\00\00\00") + (data $193 (i32.const 9004) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00#\00\00\00\00\00\00\00\00\00\00\00") + (data $194 (i32.const 9036) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00$\00\00\00\00\00\00\00\00\00\00\00") + (data $195 (i32.const 9068) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00%\00\00\00\00\00\00\00\00\00\00\00") + (data $196 (i32.const 9100) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00&\00\00\00\00\00\00\00\00\00\00\00") + (data $197 (i32.const 9132) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\'\00\00\00\00\00\00\00\00\00\00\00") + (data $198 (i32.const 9164) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") + (data $199 (i32.const 9196) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") + (data $200 (i32.const 9228) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00*\00\00\00\00\00\00\00\00\00\00\00") + (data $201 (i32.const 9260) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00+\00\00\00\00\00\00\00\00\00\00\00") + (data $202 (i32.const 9292) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") + (data $203 (i32.const 9324) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00-\00\00\00\00\00\00\00\00\00\00\00") + (data $204 (i32.const 9356) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t\00\00\00\00\00\00\00\00\00") + (data $205 (i32.const 9420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s\00\00\00\00\00\00\00") + (data $206 (i32.const 9468) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $207 (i32.const 9596) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $208 (i32.const 9676) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00.\00\00\00\00\00\00\00\00\00\00\00") + (data $209 (i32.const 9708) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00/\00\00\00\00\00\00\00\00\00\00\00") + (data $210 (i32.const 9740) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\000\00\00\00\00\00\00\00\00\00\00\00") + (data $211 (i32.const 9772) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\001\00\00\00\00\00\00\00\00\00\00\00") + (data $212 (i32.const 9804) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\002\00\00\00\00\00\00\00\00\00\00\00") + (data $213 (i32.const 9836) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\003\00\00\00\00\00\00\00\00\00\00\00") + (data $214 (i32.const 9868) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\004\00\00\00\00\00\00\00\00\00\00\00") + (data $215 (i32.const 9900) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\005\00\00\00\00\00\00\00\00\00\00\00") + (data $216 (i32.const 9932) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\006\00\00\00\00\00\00\00\00\00\00\00") + (data $217 (i32.const 9964) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\007\00\00\00\00\00\00\00\00\00\00\00") + (data $218 (i32.const 9996) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\008\00\00\00\00\00\00\00\00\00\00\00") + (data $219 (i32.const 10028) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\009\00\00\00\00\00\00\00\00\00\00\00") + (data $220 (i32.const 10060) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00:\00\00\00\00\00\00\00\00\00\00\00") + (data $221 (i32.const 10092) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00;\00\00\00\00\00\00\00\00\00\00\00") + (data $222 (i32.const 10124) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00<\00\00\00\00\00\00\00\00\00\00\00") + (data $223 (i32.const 10156) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00=\00\00\00\00\00\00\00\00\00\00\00") + (data $224 (i32.const 10188) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00>\00\00\00\00\00\00\00\00\00\00\00") + (data $225 (i32.const 10220) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00?\00\00\00\00\00\00\00\00\00\00\00") + (data $226 (i32.const 10252) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00@\00\00\00\00\00\00\00\00\00\00\00") + (data $227 (i32.const 10284) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00A\00\00\00\00\00\00\00\00\00\00\00") + (data $228 (i32.const 10316) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00B\00\00\00\00\00\00\00\00\00\00\00") + (data $229 (i32.const 10348) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00C\00\00\00\00\00\00\00\00\00\00\00") + (data $230 (i32.const 10380) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00D\00\00\00\00\00\00\00\00\00\00\00") + (data $231 (i32.const 10412) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00E\00\00\00\00\00\00\00\00\00\00\00") + (data $232 (i32.const 10444) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00F\00\00\00\00\00\00\00\00\00\00\00") + (data $233 (i32.const 10476) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00G\00\00\00\00\00\00\00\00\00\00\00") + (data $234 (i32.const 10508) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00H\00\00\00\00\00\00\00\00\00\00\00") + (data $235 (i32.const 10540) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00I\00\00\00\00\00\00\00\00\00\00\00") + (data $236 (i32.const 10572) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00J\00\00\00\00\00\00\00\00\00\00\00") + (data $237 (i32.const 10604) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00K\00\00\00\00\00\00\00\00\00\00\00") + (data $238 (i32.const 10636) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00L\00\00\00\00\00\00\00\00\00\00\00") + (data $239 (i32.const 10668) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00M\00\00\00\00\00\00\00\00\00\00\00") + (data $240 (i32.const 10700) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00N\00\00\00\00\00\00\00\00\00\00\00") + (data $241 (i32.const 10732) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00O\00\00\00\00\00\00\00\00\00\00\00") + (data $242 (i32.const 10764) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00P\00\00\00\00\00\00\00\00\00\00\00") + (data $243 (i32.const 10796) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Q\00\00\00\00\00\00\00\00\00\00\00") + (data $244 (i32.const 10828) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00R\00\00\00\00\00\00\00\00\00\00\00") + (data $245 (i32.const 10860) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00S\00\00\00\00\00\00\00\00\00\00\00") + (data $246 (i32.const 10892) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00T\00\00\00\00\00\00\00\00\00\00\00") + (data $247 (i32.const 10924) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00U\00\00\00\00\00\00\00\00\00\00\00") + (data $248 (i32.const 10956) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00V\00\00\00\00\00\00\00\00\00\00\00") + (data $249 (i32.const 10988) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00W\00\00\00\00\00\00\00\00\00\00\00") + (data $250 (i32.const 11020) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00X\00\00\00\00\00\00\00\00\00\00\00") + (data $251 (i32.const 11052) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Y\00\00\00\00\00\00\00\00\00\00\00") + (data $252 (i32.const 11084) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Z\00\00\00\00\00\00\00\00\00\00\00") + (data $253 (i32.const 11116) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00[\00\00\00\00\00\00\00\00\00\00\00") + (data $254 (i32.const 11148) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\\\00\00\00\00\00\00\00\00\00\00\00") + (data $255 (i32.const 11180) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") + (data $256 (i32.const 11212) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00^\00\00\00\00\00\00\00\00\00\00\00") + (data $257 (i32.const 11244) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00_\00\00\00\00\00\00\00\00\00\00\00") + (data $258 (i32.const 11276) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00`\00\00\00\00\00\00\00\00\00\00\00") + (data $259 (i32.const 11308) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") + (data $260 (i32.const 11340) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") + (data $261 (i32.const 11372) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") + (data $262 (i32.const 11404) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") + (data $263 (i32.const 11436) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00e\00\00\00\00\00\00\00\00\00\00\00") + (data $264 (i32.const 11468) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00f\00\00\00\00\00\00\00\00\00\00\00") + (data $265 (i32.const 11500) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00g\00\00\00\00\00\00\00\00\00\00\00") + (data $266 (i32.const 11532) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00h\00\00\00\00\00\00\00\00\00\00\00") + (data $267 (i32.const 11564) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00i\00\00\00\00\00\00\00\00\00\00\00") + (data $268 (i32.const 11596) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00j\00\00\00\00\00\00\00\00\00\00\00") + (data $269 (i32.const 11628) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00k\00\00\00\00\00\00\00\00\00\00\00") + (data $270 (i32.const 11660) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00l\00\00\00\00\00\00\00\00\00\00\00") + (data $271 (i32.const 11692) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00m\00\00\00\00\00\00\00\00\00\00\00") + (data $272 (i32.const 11724) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00n\00\00\00\00\00\00\00\00\00\00\00") + (data $273 (i32.const 11756) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00o\00\00\00\00\00\00\00\00\00\00\00") + (data $274 (i32.const 11788) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00p\00\00\00\00\00\00\00\00\00\00\00") + (data $275 (i32.const 11820) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00q\00\00\00\00\00\00\00\00\00\00\00") + (data $276 (i32.const 11852) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00r\00\00\00\00\00\00\00\00\00\00\00") + (data $277 (i32.const 11884) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $278 (i32.const 11916) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00t\00\00\00\00\00\00\00\00\00\00\00") + (data $279 (i32.const 11948) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00u\00\00\00\00\00\00\00\00\00\00\00") + (data $280 (i32.const 11980) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00v\00\00\00\00\00\00\00\00\00\00\00") + (data $281 (i32.const 12012) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00w\00\00\00\00\00\00\00\00\00\00\00") + (data $282 (i32.const 12044) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00x\00\00\00\00\00\00\00\00\00\00\00") + (data $283 (i32.const 12076) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00y\00\00\00\00\00\00\00\00\00\00\00") + (data $284 (i32.const 12108) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00z\00\00\00\00\00\00\00\00\00\00\00") + (data $285 (i32.const 12140) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00{\00\00\00\00\00\00\00\00\00\00\00") + (data $286 (i32.const 12172) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00|\00\00\00\00\00\00\00\00\00\00\00") + (data $287 (i32.const 12204) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00}\00\00\00\00\00\00\00\00\00\00\00") + (data $288 (i32.const 12236) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00~\00\00\00\00\00\00\00\00\00\00\00") + (data $289 (i32.const 12268) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\7f\00\00\00\00\00\00\00\00\00\00\00") + (data $290 (i32.const 12300) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\80\00\00\00\00\00\00\00\00\00\00\00") + (data $291 (i32.const 12332) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\81\00\00\00\00\00\00\00\00\00\00\00") + (data $292 (i32.const 12364) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\82\00\00\00\00\00\00\00\00\00\00\00") + (data $293 (i32.const 12396) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\83\00\00\00\00\00\00\00\00\00\00\00") + (data $294 (i32.const 12428) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\84\00\00\00\00\00\00\00\00\00\00\00") + (data $295 (i32.const 12460) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\85\00\00\00\00\00\00\00\00\00\00\00") + (data $296 (i32.const 12492) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\86\00\00\00\00\00\00\00\00\00\00\00") + (data $297 (i32.const 12524) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\87\00\00\00\00\00\00\00\00\00\00\00") + (data $298 (i32.const 12556) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\88\00\00\00\00\00\00\00\00\00\00\00") + (data $299 (i32.const 12588) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\89\00\00\00\00\00\00\00\00\00\00\00") + (data $300 (i32.const 12620) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8a\00\00\00\00\00\00\00\00\00\00\00") + (data $301 (i32.const 12652) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8b\00\00\00\00\00\00\00\00\00\00\00") + (data $302 (i32.const 12684) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8c\00\00\00\00\00\00\00\00\00\00\00") + (data $303 (i32.const 12716) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8d\00\00\00\00\00\00\00\00\00\00\00") + (data $304 (i32.const 12748) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8e\00\00\00\00\00\00\00\00\00\00\00") + (data $305 (i32.const 12780) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8f\00\00\00\00\00\00\00\00\00\00\00") + (data $306 (i32.const 12812) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\90\00\00\00\00\00\00\00\00\00\00\00") + (data $307 (i32.const 12844) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\91\00\00\00\00\00\00\00\00\00\00\00") + (data $308 (i32.const 12876) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\92\00\00\00\00\00\00\00\00\00\00\00") + (data $309 (i32.const 12908) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\93\00\00\00\00\00\00\00\00\00\00\00") + (data $310 (i32.const 12940) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\94\00\00\00\00\00\00\00\00\00\00\00") + (data $311 (i32.const 12972) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\95\00\00\00\00\00\00\00\00\00\00\00") + (data $312 (i32.const 13004) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\96\00\00\00\00\00\00\00\00\00\00\00") + (data $313 (i32.const 13036) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\97\00\00\00\00\00\00\00\00\00\00\00") + (data $314 (i32.const 13068) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\98\00\00\00\00\00\00\00\00\00\00\00") + (data $315 (i32.const 13100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y\00") + (data $316 (i32.const 13148) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.\00") + (data $317 (i32.const 13244) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\99\00\00\00\00\00\00\00\00\00\00\00") + (data $318 (i32.const 13276) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00\e02\00\00\003\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 3\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00`$\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c00\00\00\e00\00\00\001\00\00 1\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\e0#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\00$\00\00\80$\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00@1\00\00`1\00\00\801\00\00\a01\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c01\00\00\e01\00\00\002\00\00 2\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 $\00\00\e0!\00\00\00\"\00\00 \"\00\00@\"\00\00`\"\00\00\80\"\00\00\a0\"\00\00\c0\"\00\00\e0\"\00\00\00#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 ,\00\00\d03\00\00\a0 \00\00\c0 \00\00\e0 \00\00\00!\00\00 !\00\00@!\00\00`!\00\00\80!\00\00\a0!\00\00\c0!\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00@2\00\00`2\00\00\802\00\00\a02\00\00\c0&\00\00\e0&\00\00\00\'\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\c0(\00\00\a0\'\00\00\c0\'\00\00\e0\'\00\00\e0(\00\00\c0-\00\00\e0-\00\00\80.\00\00\a0.\00\00\c0.\00\00\00)\00\00\00.\00\00 .\00\00\e0.\00\00\00/\00\00 /\00\00@,\00\00`,\00\00 )\00\00@)\00\00@/\00\00`/\00\00\80/\00\00`)\00\00\a0/\00\00\c0/\00\00\e0/\00\00\c0,\00\00\e0,\00\00\00-\00\00 -\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 #\00\00@#\00\00`#\00\00\80#\00\00\a0#\00\00\c0#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00@$\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\80)\00\00\a0)\00\00\c0)\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\00\000\00\00 0\00\00@0\00\00`*\00\00\80*\00\00\a0*\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00`0\00\00\800\00\00\a00\00\00\00(\00\00 (\00\00@(\00\00@+\00\00`+\00\00\80+\00\00@.\00\00`.\00\00\80,\00\00\a0,\00\00@-\00\00`-\00\00\80-\00\00\a0-\00\00`(\00\00\80(\00\00\a0(\00\00\a0+\00\00\c0+\00\00\e0+\00\00\00,\00\00") + (data $319 (i32.const 14220) ",\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\10\00\00\00\f03\00\00\f03\00\00\9c\03\00\00\e7\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $320 (i32.const 14268) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80\00\00\00\00") + (data $321 (i32.const 14300) ",\00\00\00\00\00\00\00\00\00\00\00\1b\00\00\00\10\00\00\00\d07\00\00\d07\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $322 (i32.const 14348) "\1c\00\00\00\00\00\00\00\00\00\00\00\1c\00\00\00\08\00\00\00\9a\00\00\00\00\00\00\00\00\00\00\00") + (data $323 (i32.const 14380) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $324 (i32.const 14412) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 \00\00\00") + (data $325 (i32.const 14492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $326 (i32.const 14540) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00`8\00\00\00\00\00\00\b08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $327 (i32.const 14588) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006\00\00\00\00\00\00\00\00\00") + (data $328 (i32.const 14716) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") + (data $329 (i32.const 14780) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\000\00\00\00\00\00\00\00\00\00\00\00") + (data $330 (i32.const 14812) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\00") + (data $331 (i32.const 15212) "\1c\04\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $332 (i32.const 16268) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z\00\00\00\00\00") + (data $333 (i32.const 16364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $334 (i32.const 16428) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 \00\00\00\00\00\00\00\00\00") + (data $335 (i32.const 16540) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $336 (i32.const 16588) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00@@\00\00\00\00\00\00\b0@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $337 (i32.const 16636) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n\00\00\00\00\00\00\00") + (data $338 (i32.const 16684) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\000\00x\00\00\00\00\00\00\00\00\00") + (data $339 (i32.const 16716) "\1c\00\00\00\00\00\00\00\00\00\00\00)\00\00\00\08\00\00\00\9b\00\00\00\00\00\00\00\00\00\00\00") + (data $340 (i32.const 16748) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00\n\00\n\00\00\00\00\00\00\00\00\00") + (data $341 (i32.const 16780) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $342 (i32.const 16908) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>\00\00\00") + (data $343 (i32.const 16988) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!\00\00\00\00\00\00\00\00\00\00\00") + (data $344 (i32.const 17100) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00g\00e\00n\00e\00r\00i\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $345 (i32.const 17180) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") + (data $346 (i32.const 17212) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00:\00 \00\00\00\00\00\00\00\00\00") + (data $347 (i32.const 17244) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") + (data $348 (i32.const 17276) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") + (data $349 (i32.const 17308) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pC\00\00\00\00\00\00\90C\00\00") + (data $350 (i32.const 17340) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $351 (i32.const 17372) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00,\00 \00\00\00\00\00\00\00\00\00") + (data $352 (i32.const 17404) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00\d0C\00\00\00\00\00\00\f0C\00\00") + (data $353 (i32.const 17436) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") + (data $354 (i32.const 17564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 \00") + (data $355 (i32.const 17612) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $356 (i32.const 17644) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $357 (i32.const 17676) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $358 (i32.const 17708) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $359 (i32.const 17740) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 \00") + (data $360 (i32.const 17836) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $361 (i32.const 17900) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!\00\00\00\00\00\00\00") + (data $362 (i32.const 18012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 \00\00\00\00\00") + (data $363 (i32.const 18060) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $364 (i32.const 18108) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pF\00\00\00\00\00\00\a0F\00\00") + (data $365 (i32.const 18140) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pF\00\00\00\00\00\00\a0F\00\00") + (data $366 (i32.const 18172) "\1c\00\00\00\00\00\00\00\00\00\00\005\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") + (data $367 (i32.const 18204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 \00") + (data $368 (i32.const 18268) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00P\00C\00 \00=\00 \00\00\00") + (data $369 (i32.const 18300) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $370 (i32.const 18348) "\1c\00\00\00\00\00\00\00\00\00\00\005\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") + (data $371 (i32.const 18380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 \00") + (data $372 (i32.const 18428) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00(\00\00\00\00\00\00\00\00\00") + (data $373 (i32.const 18460) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\14\00\00\00\e0G\00\00\00\00\00\00\10H\00\00\00\00\00\00\90C\00\00\00\00\00\00\00\00\00\00") + (data $374 (i32.const 18508) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 \00\00\00\00\00\00\00\00\00") + (data $375 (i32.const 18588) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00") + (data $376 (i32.const 18652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 \00\00\00") + (data $377 (i32.const 18700) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x\00") + (data $378 (i32.const 18732) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 \00\00\00") + (data $379 (i32.const 18764) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00,\00\n\00 \00 \00\00\00\00\00") + (data $380 (i32.const 18796) "|\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00`\00\00\00\f0H\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00@I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00`I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00`I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $381 (i32.const 18924) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t\00") + (data $382 (i32.const 18972) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $383 (i32.const 19052) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $384 (i32.const 19084) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $385 (i32.const 19116) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $386 (i32.const 19148) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $387 (i32.const 19180) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00S\00P\00I\00 \00r\00u\00n\00n\00i\00n\00g\00 \00n\00o\00t\00 \00s\00u\00p\00p\00o\00r\00t\00e\00d\00 \00y\00e\00t\00\00\00") + (data $388 (i32.const 19260) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00d\00e\00x\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $389 (i32.const 19324) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $390 (i32.const 19404) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $391 (i32.const 19436) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $392 (i32.const 19500) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 \00\00\00\00\00\00\00") + (data $393 (i32.const 19580) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00") + (data $394 (i32.const 19676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 \00\00\00\00\00") + (data $395 (i32.const 19724) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00\90L\00\00\00\00\00\00\f0L\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $396 (i32.const 19772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $397 (i32.const 19836) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $398 (i32.const 19868) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $399 (i32.const 19900) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d\00\00\00") + (data $400 (i32.const 19964) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d\00\00\00\00\00") + (data $401 (i32.const 20032) "<\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\02A\00\00B\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\01\00\00\00\00\00\00\00\00\00\00$\t\00\00 \00\00\00\00\00\00\00\00\00\00\00\04A\00\00 \00\00\00\00\00\00\00\02\01\00\00\02\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00\00\00\00\00 \00\00\00 \00\00\00\02A\00\00d\00\00\00\00\00\00\00") + (table $0 158 158 funcref) + (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $assembly/index/disassemble~anonymous|0 $assembly/api-generic/runVm~anonymous|0 $assembly/api-generic/runVm~anonymous|1) + (export "InputKind.Generic" (global $assembly/index/InputKind.Generic)) + (export "InputKind.SPI" (global $assembly/index/InputKind.SPI)) + (export "HasMetadata.Yes" (global $assembly/index/HasMetadata.Yes)) + (export "HasMetadata.No" (global $assembly/index/HasMetadata.No)) + (export "nextStep" (func $assembly/api/nextStep)) + (export "nSteps" (func $assembly/api/nSteps)) + (export "getProgramCounter" (func $assembly/api/getProgramCounter)) + (export "setNextProgramCounter" (func $assembly/api/setNextProgramCounter)) + (export "getStatus" (func $assembly/api/getStatus)) + (export "getExitArg" (func $assembly/api/getExitArg)) + (export "getGasLeft" (func $assembly/api/getGasLeft)) + (export "setGasLeft" (func $assembly/api/setGasLeft)) + (export "getRegisters" (func $assembly/api/getRegisters)) + (export "getPageDump" (func $assembly/api/getPageDump)) + (export "__new" (func $~lib/rt/itcms/__new)) + (export "__pin" (func $~lib/rt/itcms/__pin)) + (export "__unpin" (func $~lib/rt/itcms/__unpin)) + (export "__collect" (func $~lib/rt/itcms/__collect)) + (export "__rtti_base" (global $~lib/rt/__rtti_base)) + (export "memory" (memory $0)) + (export "__setArgumentsLength" (func $~setArgumentsLength)) + (export "disassemble" (func $export:assembly/index/disassemble)) + (export "runProgram" (func $export:assembly/index/runProgram)) + (export "runVm" (func $export:assembly/api-generic/runVm@varargs)) + (export "getAssembly" (func $export:assembly/api-generic/getAssembly)) + (export "wrapAsProgram" (func $export:assembly/program-build/wrapAsProgram)) + (export "resetGeneric" (func $export:assembly/api/resetGeneric)) + (export "resetGenericWithMemory" (func $export:assembly/api/resetGenericWithMemory)) + (export "setRegisters" (func $export:assembly/api/setRegisters)) + (export "setMemory" (func $export:assembly/api/setMemory)) + (start $~start) + (func $~lib/rt/itcms/Object#set:nextWithColor (param $this i32) (param $nextWithColor i32) + local.get $this + local.get $nextWithColor + i32.store offset=4 + ) + (func $~lib/rt/itcms/Object#set:prev (param $this i32) (param $prev i32) + local.get $this + local.get $prev + i32.store offset=8 + ) + (func $~lib/rt/itcms/initLazy (param $space i32) (result i32) + local.get $space + local.get $space + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $space + local.get $space + call $~lib/rt/itcms/Object#set:prev + local.get $space + return + ) + (func $~lib/rt/itcms/Object#get:nextWithColor (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/rt/itcms/Object#get:next (param $this i32) (result i32) + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.const -1 + i32.xor + i32.and + return + ) + (func $~lib/rt/itcms/Object#get:color (param $this i32) (result i32) + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.and + return + ) + (func $~lib/rt/itcms/visitRoots (param $cookie i32) + (local $pn i32) + (local $iter i32) + local.get $cookie + call $~lib/rt/__visit_globals + global.get $~lib/rt/itcms/pinSpace + local.set $pn + local.get $pn + call $~lib/rt/itcms/Object#get:next + local.set $iter + loop $while-continue|0 + local.get $iter + local.get $pn + i32.ne + if + i32.const 1 + drop + local.get $iter + call $~lib/rt/itcms/Object#get:color + i32.const 3 + i32.eq + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 160 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $iter + i32.const 20 + i32.add + local.get $cookie + call $~lib/rt/__visit_members + local.get $iter + call $~lib/rt/itcms/Object#get:next + local.set $iter + br $while-continue|0 + end + end + ) + (func $~lib/rt/itcms/Object#set:color (param $this i32) (param $color i32) + local.get $this + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $color + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + ) + (func $~lib/rt/itcms/Object#get:prev (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/rt/itcms/Object#set:next (param $this i32) (param $obj i32) + local.get $this + local.get $obj + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.and + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + ) + (func $~lib/rt/itcms/Object#unlink (param $this i32) + (local $next i32) + (local $prev i32) + local.get $this + call $~lib/rt/itcms/Object#get:next + local.set $next + local.get $next + i32.const 0 + i32.eq + if + i32.const 1 + drop + local.get $this + call $~lib/rt/itcms/Object#get:prev + i32.const 0 + i32.eq + if (result i32) + local.get $this + global.get $~lib/memory/__heap_base + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 128 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + return + end + local.get $this + call $~lib/rt/itcms/Object#get:prev + local.set $prev + i32.const 1 + drop + local.get $prev + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 132 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $next + local.get $prev + call $~lib/rt/itcms/Object#set:prev + local.get $prev + local.get $next + call $~lib/rt/itcms/Object#set:next + ) + (func $~lib/rt/itcms/Object#get:rtId (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/shared/typeinfo/Typeinfo#get:flags (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/__typeinfo (param $id i32) (result i32) + (local $ptr i32) + global.get $~lib/rt/__rtti_base + local.set $ptr + local.get $id + local.get $ptr + i32.load + i32.gt_u + if + i32.const 480 + i32.const 544 + i32.const 21 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $ptr + i32.const 4 + i32.add + local.get $id + i32.const 4 + i32.mul + i32.add + call $~lib/shared/typeinfo/Typeinfo#get:flags + return + ) + (func $~lib/rt/itcms/Object#get:isPointerfree (param $this i32) (result i32) + (local $rtId i32) + local.get $this + call $~lib/rt/itcms/Object#get:rtId + local.set $rtId + local.get $rtId + i32.const 2 + i32.le_u + if (result i32) + i32.const 1 + else + local.get $rtId + call $~lib/rt/__typeinfo + i32.const 32 + i32.and + i32.const 0 + i32.ne + end + return + ) + (func $~lib/rt/itcms/Object#linkTo (param $this i32) (param $list i32) (param $withColor i32) + (local $prev i32) + local.get $list + call $~lib/rt/itcms/Object#get:prev + local.set $prev + local.get $this + local.get $list + local.get $withColor + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $this + local.get $prev + call $~lib/rt/itcms/Object#set:prev + local.get $prev + local.get $this + call $~lib/rt/itcms/Object#set:next + local.get $list + local.get $this + call $~lib/rt/itcms/Object#set:prev + ) + (func $~lib/rt/itcms/Object#makeGray (param $this i32) + (local $1 i32) + local.get $this + global.get $~lib/rt/itcms/iter + i32.eq + if + local.get $this + call $~lib/rt/itcms/Object#get:prev + local.tee $1 + i32.eqz + if (result i32) + i32.const 0 + i32.const 352 + i32.const 148 + i32.const 30 + call $~lib/builtins/abort + unreachable + else + local.get $1 + end + global.set $~lib/rt/itcms/iter + end + local.get $this + call $~lib/rt/itcms/Object#unlink + local.get $this + global.get $~lib/rt/itcms/toSpace + local.get $this + call $~lib/rt/itcms/Object#get:isPointerfree + if (result i32) + global.get $~lib/rt/itcms/white + i32.eqz + else + i32.const 2 + end + call $~lib/rt/itcms/Object#linkTo + ) + (func $~lib/rt/itcms/__visit (param $ptr i32) (param $cookie i32) + (local $obj i32) + local.get $ptr + i32.eqz + if + return + end + local.get $ptr + i32.const 20 + i32.sub + local.set $obj + i32.const 0 + drop + local.get $obj + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eq + if + local.get $obj + call $~lib/rt/itcms/Object#makeGray + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.add + global.set $~lib/rt/itcms/visitCount + end + ) + (func $~lib/rt/itcms/visitStack (param $cookie i32) + (local $ptr i32) + global.get $~lib/memory/__stack_pointer + local.set $ptr + loop $while-continue|0 + local.get $ptr + global.get $~lib/memory/__heap_base + i32.lt_u + if + local.get $ptr + i32.load + local.get $cookie + call $~lib/rt/itcms/__visit + local.get $ptr + i32.const 4 + i32.add + local.set $ptr + br $while-continue|0 + end + end + ) + (func $~lib/rt/common/BLOCK#get:mmInfo (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/itcms/Object#get:size (param $this i32) (result i32) + i32.const 4 + local.get $this + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + return + ) + (func $~lib/rt/tlsf/Root#set:flMap (param $this i32) (param $flMap i32) + local.get $this + local.get $flMap + i32.store + ) + (func $~lib/rt/common/BLOCK#set:mmInfo (param $this i32) (param $mmInfo i32) + local.get $this + local.get $mmInfo + i32.store + ) + (func $~lib/rt/tlsf/Block#set:prev (param $this i32) (param $prev i32) + local.get $this + local.get $prev + i32.store offset=4 + ) + (func $~lib/rt/tlsf/Block#set:next (param $this i32) (param $next i32) + local.get $this + local.get $next + i32.store offset=8 + ) + (func $~lib/rt/tlsf/Block#get:prev (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/rt/tlsf/Block#get:next (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/rt/tlsf/Root#get:flMap (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/tlsf/removeBlock (param $root i32) (param $block i32) + (local $blockInfo i32) + (local $size i32) + (local $fl i32) + (local $sl i32) + (local $6 i32) + (local $7 i32) + (local $boundedSize i32) + (local $prev i32) + (local $next i32) + (local $root|11 i32) + (local $fl|12 i32) + (local $sl|13 i32) + (local $root|14 i32) + (local $fl|15 i32) + (local $sl|16 i32) + (local $head i32) + (local $root|18 i32) + (local $fl|19 i32) + (local $slMap i32) + (local $root|21 i32) + (local $fl|22 i32) + (local $slMap|23 i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $blockInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 268 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.set $size + i32.const 1 + drop + local.get $size + i32.const 12 + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 270 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + local.tee $6 + i32.const 1073741820 + local.tee $7 + local.get $6 + local.get $7 + i32.lt_u + select + local.set $boundedSize + i32.const 31 + local.get $boundedSize + i32.clz + i32.sub + local.set $fl + local.get $boundedSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 284 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $block + call $~lib/rt/tlsf/Block#get:prev + local.set $prev + local.get $block + call $~lib/rt/tlsf/Block#get:next + local.set $next + local.get $prev + if + local.get $prev + local.get $next + call $~lib/rt/tlsf/Block#set:next + end + local.get $next + if + local.get $next + local.get $prev + call $~lib/rt/tlsf/Block#set:prev + end + local.get $block + block $~lib/rt/tlsf/GETHEAD|inlined.0 (result i32) + local.get $root + local.set $root|11 + local.get $fl + local.set $fl|12 + local.get $sl + local.set $sl|13 + local.get $root|11 + local.get $fl|12 + i32.const 4 + i32.shl + local.get $sl|13 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.0 + end + i32.eq + if + local.get $root + local.set $root|14 + local.get $fl + local.set $fl|15 + local.get $sl + local.set $sl|16 + local.get $next + local.set $head + local.get $root|14 + local.get $fl|15 + i32.const 4 + i32.shl + local.get $sl|16 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head + i32.store offset=96 + local.get $next + i32.eqz + if + block $~lib/rt/tlsf/GETSL|inlined.0 (result i32) + local.get $root + local.set $root|18 + local.get $fl + local.set $fl|19 + local.get $root|18 + local.get $fl|19 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.0 + end + local.set $slMap + local.get $root + local.set $root|21 + local.get $fl + local.set $fl|22 + local.get $slMap + i32.const 1 + local.get $sl + i32.shl + i32.const -1 + i32.xor + i32.and + local.tee $slMap + local.set $slMap|23 + local.get $root|21 + local.get $fl|22 + i32.const 2 + i32.shl + i32.add + local.get $slMap|23 + i32.store offset=4 + local.get $slMap + i32.eqz + if + local.get $root + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 1 + local.get $fl + i32.shl + i32.const -1 + i32.xor + i32.and + call $~lib/rt/tlsf/Root#set:flMap + end + end + end + ) + (func $~lib/rt/tlsf/insertBlock (param $root i32) (param $block i32) + (local $blockInfo i32) + (local $block|3 i32) + (local $right i32) + (local $rightInfo i32) + (local $block|6 i32) + (local $block|7 i32) + (local $left i32) + (local $leftInfo i32) + (local $size i32) + (local $fl i32) + (local $sl i32) + (local $13 i32) + (local $14 i32) + (local $boundedSize i32) + (local $root|16 i32) + (local $fl|17 i32) + (local $sl|18 i32) + (local $head i32) + (local $root|20 i32) + (local $fl|21 i32) + (local $sl|22 i32) + (local $head|23 i32) + (local $root|24 i32) + (local $fl|25 i32) + (local $root|26 i32) + (local $fl|27 i32) + (local $slMap i32) + i32.const 1 + drop + local.get $block + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 201 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $blockInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 203 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETRIGHT|inlined.0 (result i32) + local.get $block + local.set $block|3 + local.get $block|3 + i32.const 4 + i32.add + local.get $block|3 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.0 + end + local.set $right + local.get $right + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $rightInfo + local.get $rightInfo + i32.const 1 + i32.and + if + local.get $root + local.get $right + call $~lib/rt/tlsf/removeBlock + local.get $block + local.get $blockInfo + i32.const 4 + i32.add + local.get $rightInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + local.tee $blockInfo + call $~lib/rt/common/BLOCK#set:mmInfo + block $~lib/rt/tlsf/GETRIGHT|inlined.1 (result i32) + local.get $block + local.set $block|6 + local.get $block|6 + i32.const 4 + i32.add + local.get $block|6 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.1 + end + local.set $right + local.get $right + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $rightInfo + end + local.get $blockInfo + i32.const 2 + i32.and + if + block $~lib/rt/tlsf/GETFREELEFT|inlined.0 (result i32) + local.get $block + local.set $block|7 + local.get $block|7 + i32.const 4 + i32.sub + i32.load + br $~lib/rt/tlsf/GETFREELEFT|inlined.0 + end + local.set $left + local.get $left + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $leftInfo + i32.const 1 + drop + local.get $leftInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 221 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $root + local.get $left + call $~lib/rt/tlsf/removeBlock + local.get $left + local.set $block + local.get $block + local.get $leftInfo + i32.const 4 + i32.add + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + local.tee $blockInfo + call $~lib/rt/common/BLOCK#set:mmInfo + end + local.get $right + local.get $rightInfo + i32.const 2 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.set $size + i32.const 1 + drop + local.get $size + i32.const 12 + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 233 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + i32.const 1 + drop + local.get $block + i32.const 4 + i32.add + local.get $size + i32.add + local.get $right + i32.eq + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 234 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $right + i32.const 4 + i32.sub + local.get $block + i32.store + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + local.tee $13 + i32.const 1073741820 + local.tee $14 + local.get $13 + local.get $14 + i32.lt_u + select + local.set $boundedSize + i32.const 31 + local.get $boundedSize + i32.clz + i32.sub + local.set $fl + local.get $boundedSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 251 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETHEAD|inlined.1 (result i32) + local.get $root + local.set $root|16 + local.get $fl + local.set $fl|17 + local.get $sl + local.set $sl|18 + local.get $root|16 + local.get $fl|17 + i32.const 4 + i32.shl + local.get $sl|18 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.1 + end + local.set $head + local.get $block + i32.const 0 + call $~lib/rt/tlsf/Block#set:prev + local.get $block + local.get $head + call $~lib/rt/tlsf/Block#set:next + local.get $head + if + local.get $head + local.get $block + call $~lib/rt/tlsf/Block#set:prev + end + local.get $root + local.set $root|20 + local.get $fl + local.set $fl|21 + local.get $sl + local.set $sl|22 + local.get $block + local.set $head|23 + local.get $root|20 + local.get $fl|21 + i32.const 4 + i32.shl + local.get $sl|22 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head|23 + i32.store offset=96 + local.get $root + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 1 + local.get $fl + i32.shl + i32.or + call $~lib/rt/tlsf/Root#set:flMap + local.get $root + local.set $root|26 + local.get $fl + local.set $fl|27 + block $~lib/rt/tlsf/GETSL|inlined.1 (result i32) + local.get $root + local.set $root|24 + local.get $fl + local.set $fl|25 + local.get $root|24 + local.get $fl|25 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.1 + end + i32.const 1 + local.get $sl + i32.shl + i32.or + local.set $slMap + local.get $root|26 + local.get $fl|27 + i32.const 2 + i32.shl + i32.add + local.get $slMap + i32.store offset=4 + ) + (func $~lib/rt/tlsf/addMemory (param $root i32) (param $start i32) (param $endU64 i64) (result i32) + (local $end i32) + (local $root|4 i32) + (local $tail i32) + (local $tailInfo i32) + (local $size i32) + (local $leftSize i32) + (local $left i32) + (local $root|10 i32) + (local $tail|11 i32) + local.get $endU64 + i32.wrap_i64 + local.set $end + i32.const 1 + drop + local.get $start + i64.extend_i32_u + local.get $endU64 + i64.le_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 382 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $start + i32.const 4 + i32.add + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + i32.const 4 + i32.sub + local.set $start + local.get $end + i32.const 15 + i32.const -1 + i32.xor + i32.and + local.set $end + block $~lib/rt/tlsf/GETTAIL|inlined.0 (result i32) + local.get $root + local.set $root|4 + local.get $root|4 + i32.load offset=1568 + br $~lib/rt/tlsf/GETTAIL|inlined.0 + end + local.set $tail + i32.const 0 + local.set $tailInfo + local.get $tail + if + i32.const 1 + drop + local.get $start + local.get $tail + i32.const 4 + i32.add + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 389 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $start + i32.const 16 + i32.sub + local.get $tail + i32.eq + if + local.get $start + i32.const 16 + i32.sub + local.set $start + local.get $tail + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $tailInfo + else + end + else + i32.const 1 + drop + local.get $start + local.get $root + i32.const 1572 + i32.add + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 402 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + end + local.get $end + local.get $start + i32.sub + local.set $size + local.get $size + i32.const 4 + i32.const 12 + i32.add + i32.const 4 + i32.add + i32.lt_u + if + i32.const 0 + return + end + local.get $size + i32.const 2 + i32.const 4 + i32.mul + i32.sub + local.set $leftSize + local.get $start + local.set $left + local.get $left + local.get $leftSize + i32.const 1 + i32.or + local.get $tailInfo + i32.const 2 + i32.and + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $left + i32.const 0 + call $~lib/rt/tlsf/Block#set:prev + local.get $left + i32.const 0 + call $~lib/rt/tlsf/Block#set:next + local.get $start + i32.const 4 + i32.add + local.get $leftSize + i32.add + local.set $tail + local.get $tail + i32.const 0 + i32.const 2 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.set $root|10 + local.get $tail + local.set $tail|11 + local.get $root|10 + local.get $tail|11 + i32.store offset=1568 + local.get $root + local.get $left + call $~lib/rt/tlsf/insertBlock + i32.const 1 + return + ) + (func $~lib/rt/tlsf/initialize + (local $rootOffset i32) + (local $pagesBefore i32) + (local $pagesNeeded i32) + (local $root i32) + (local $root|4 i32) + (local $tail i32) + (local $fl i32) + (local $root|7 i32) + (local $fl|8 i32) + (local $slMap i32) + (local $sl i32) + (local $root|11 i32) + (local $fl|12 i32) + (local $sl|13 i32) + (local $head i32) + (local $memStart i32) + i32.const 0 + drop + global.get $~lib/memory/__heap_base + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + local.set $rootOffset + memory.size + local.set $pagesBefore + local.get $rootOffset + i32.const 1572 + i32.add + i32.const 65535 + i32.add + i32.const 65535 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.shr_u + local.set $pagesNeeded + local.get $pagesNeeded + local.get $pagesBefore + i32.gt_s + if (result i32) + local.get $pagesNeeded + local.get $pagesBefore + i32.sub + memory.grow + i32.const 0 + i32.lt_s + else + i32.const 0 + end + if + unreachable + end + local.get $rootOffset + local.set $root + local.get $root + i32.const 0 + call $~lib/rt/tlsf/Root#set:flMap + local.get $root + local.set $root|4 + i32.const 0 + local.set $tail + local.get $root|4 + local.get $tail + i32.store offset=1568 + i32.const 0 + local.set $fl + loop $for-loop|0 + local.get $fl + i32.const 23 + i32.lt_u + if + local.get $root + local.set $root|7 + local.get $fl + local.set $fl|8 + i32.const 0 + local.set $slMap + local.get $root|7 + local.get $fl|8 + i32.const 2 + i32.shl + i32.add + local.get $slMap + i32.store offset=4 + i32.const 0 + local.set $sl + loop $for-loop|1 + local.get $sl + i32.const 16 + i32.lt_u + if + local.get $root + local.set $root|11 + local.get $fl + local.set $fl|12 + local.get $sl + local.set $sl|13 + i32.const 0 + local.set $head + local.get $root|11 + local.get $fl|12 + i32.const 4 + i32.shl + local.get $sl|13 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head + i32.store offset=96 + local.get $sl + i32.const 1 + i32.add + local.set $sl + br $for-loop|1 + end + end + local.get $fl + i32.const 1 + i32.add + local.set $fl + br $for-loop|0 + end + end + local.get $rootOffset + i32.const 1572 + i32.add + local.set $memStart + i32.const 0 + drop + local.get $root + local.get $memStart + memory.size + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + drop + local.get $root + global.set $~lib/rt/tlsf/ROOT + ) + (func $~lib/rt/tlsf/checkUsedBlock (param $ptr i32) (result i32) + (local $block i32) + local.get $ptr + i32.const 4 + i32.sub + local.set $block + local.get $ptr + i32.const 0 + i32.ne + if (result i32) + local.get $ptr + i32.const 15 + i32.and + i32.eqz + else + i32.const 0 + end + if (result i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 1 + i32.and + i32.eqz + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 562 + i32.const 3 + call $~lib/builtins/abort + unreachable + end + local.get $block + return + ) + (func $~lib/rt/tlsf/freeBlock (param $root i32) (param $block i32) + i32.const 0 + drop + local.get $block + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 1 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.get $block + call $~lib/rt/tlsf/insertBlock + ) + (func $~lib/rt/tlsf/__free (param $ptr i32) + local.get $ptr + global.get $~lib/memory/__heap_base + i32.lt_u + if + return + end + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $ptr + call $~lib/rt/tlsf/checkUsedBlock + call $~lib/rt/tlsf/freeBlock + ) + (func $~lib/rt/itcms/free (param $obj i32) + local.get $obj + global.get $~lib/memory/__heap_base + i32.lt_u + if + local.get $obj + i32.const 0 + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $obj + i32.const 0 + call $~lib/rt/itcms/Object#set:prev + else + global.get $~lib/rt/itcms/total + local.get $obj + call $~lib/rt/itcms/Object#get:size + i32.sub + global.set $~lib/rt/itcms/total + i32.const 0 + drop + local.get $obj + i32.const 4 + i32.add + call $~lib/rt/tlsf/__free + end + ) + (func $~lib/rt/itcms/step (result i32) + (local $obj i32) + (local $1 i32) + (local $black i32) + (local $from i32) + block $break|0 + block $case2|0 + block $case1|0 + block $case0|0 + global.get $~lib/rt/itcms/state + local.set $1 + local.get $1 + i32.const 0 + i32.eq + br_if $case0|0 + local.get $1 + i32.const 1 + i32.eq + br_if $case1|0 + local.get $1 + i32.const 2 + i32.eq + br_if $case2|0 + br $break|0 + end + i32.const 1 + global.set $~lib/rt/itcms/state + i32.const 0 + global.set $~lib/rt/itcms/visitCount + i32.const 0 + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/iter + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + global.get $~lib/rt/itcms/white + i32.eqz + local.set $black + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + loop $while-continue|1 + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + global.set $~lib/rt/itcms/iter + local.get $obj + call $~lib/rt/itcms/Object#get:color + local.get $black + i32.ne + if + local.get $obj + local.get $black + call $~lib/rt/itcms/Object#set:color + i32.const 0 + global.set $~lib/rt/itcms/visitCount + local.get $obj + i32.const 20 + i32.add + i32.const 0 + call $~lib/rt/__visit_members + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + local.get $obj + call $~lib/rt/itcms/Object#get:next + local.set $obj + br $while-continue|1 + end + end + i32.const 0 + global.set $~lib/rt/itcms/visitCount + i32.const 0 + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.eq + if + i32.const 0 + call $~lib/rt/itcms/visitStack + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + loop $while-continue|2 + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + call $~lib/rt/itcms/Object#get:color + local.get $black + i32.ne + if + local.get $obj + local.get $black + call $~lib/rt/itcms/Object#set:color + local.get $obj + i32.const 20 + i32.add + i32.const 0 + call $~lib/rt/__visit_members + end + local.get $obj + call $~lib/rt/itcms/Object#get:next + local.set $obj + br $while-continue|2 + end + end + global.get $~lib/rt/itcms/fromSpace + local.set $from + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/fromSpace + local.get $from + global.set $~lib/rt/itcms/toSpace + local.get $black + global.set $~lib/rt/itcms/white + local.get $from + call $~lib/rt/itcms/Object#get:next + global.set $~lib/rt/itcms/iter + i32.const 2 + global.set $~lib/rt/itcms/state + end + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + global.get $~lib/rt/itcms/iter + local.set $obj + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + call $~lib/rt/itcms/Object#get:next + global.set $~lib/rt/itcms/iter + i32.const 1 + drop + local.get $obj + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eqz + i32.eq + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 229 + i32.const 20 + call $~lib/builtins/abort + unreachable + end + local.get $obj + call $~lib/rt/itcms/free + i32.const 10 + return + end + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + call $~lib/rt/itcms/Object#set:nextWithColor + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + call $~lib/rt/itcms/Object#set:prev + i32.const 0 + global.set $~lib/rt/itcms/state + br $break|0 + end + i32.const 0 + return + ) + (func $~lib/rt/itcms/interrupt + (local $budget i32) + i32.const 0 + drop + i32.const 0 + drop + i32.const 1024 + i32.const 200 + i32.mul + i32.const 100 + i32.div_u + local.set $budget + loop $do-loop|0 + local.get $budget + call $~lib/rt/itcms/step + i32.sub + local.set $budget + global.get $~lib/rt/itcms/state + i32.const 0 + i32.eq + if + i32.const 0 + drop + global.get $~lib/rt/itcms/total + i64.extend_i32_u + i32.const 200 + i64.extend_i32_u + i64.mul + i64.const 100 + i64.div_u + i32.wrap_i64 + i32.const 1024 + i32.add + global.set $~lib/rt/itcms/threshold + i32.const 0 + drop + return + end + local.get $budget + i32.const 0 + i32.gt_s + br_if $do-loop|0 + end + i32.const 0 + drop + global.get $~lib/rt/itcms/total + i32.const 1024 + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.sub + i32.const 1024 + i32.lt_u + i32.mul + i32.add + global.set $~lib/rt/itcms/threshold + i32.const 0 + drop + ) + (func $~lib/rt/tlsf/computeSize (param $size i32) (result i32) + local.get $size + i32.const 12 + i32.le_u + if (result i32) + i32.const 12 + else + local.get $size + i32.const 4 + i32.add + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + i32.const 4 + i32.sub + end + return + ) + (func $~lib/rt/tlsf/prepareSize (param $size i32) (result i32) + local.get $size + i32.const 1073741820 + i32.gt_u + if + i32.const 288 + i32.const 624 + i32.const 461 + i32.const 29 + call $~lib/builtins/abort + unreachable + end + local.get $size + call $~lib/rt/tlsf/computeSize + return + ) + (func $~lib/rt/tlsf/roundSize (param $size i32) (result i32) + local.get $size + i32.const 536870910 + i32.lt_u + if (result i32) + local.get $size + i32.const 1 + i32.const 27 + local.get $size + i32.clz + i32.sub + i32.shl + i32.add + i32.const 1 + i32.sub + else + local.get $size + end + return + ) + (func $~lib/rt/tlsf/searchBlock (param $root i32) (param $size i32) (result i32) + (local $fl i32) + (local $sl i32) + (local $requestSize i32) + (local $root|5 i32) + (local $fl|6 i32) + (local $slMap i32) + (local $head i32) + (local $flMap i32) + (local $root|10 i32) + (local $fl|11 i32) + (local $root|12 i32) + (local $fl|13 i32) + (local $sl|14 i32) + (local $root|15 i32) + (local $fl|16 i32) + (local $sl|17 i32) + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + call $~lib/rt/tlsf/roundSize + local.set $requestSize + i32.const 4 + i32.const 8 + i32.mul + i32.const 1 + i32.sub + local.get $requestSize + i32.clz + i32.sub + local.set $fl + local.get $requestSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 334 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETSL|inlined.2 (result i32) + local.get $root + local.set $root|5 + local.get $fl + local.set $fl|6 + local.get $root|5 + local.get $fl|6 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.2 + end + i32.const 0 + i32.const -1 + i32.xor + local.get $sl + i32.shl + i32.and + local.set $slMap + i32.const 0 + local.set $head + local.get $slMap + i32.eqz + if + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 0 + i32.const -1 + i32.xor + local.get $fl + i32.const 1 + i32.add + i32.shl + i32.and + local.set $flMap + local.get $flMap + i32.eqz + if + i32.const 0 + local.set $head + else + local.get $flMap + i32.ctz + local.set $fl + block $~lib/rt/tlsf/GETSL|inlined.3 (result i32) + local.get $root + local.set $root|10 + local.get $fl + local.set $fl|11 + local.get $root|10 + local.get $fl|11 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.3 + end + local.set $slMap + i32.const 1 + drop + local.get $slMap + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 347 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETHEAD|inlined.2 (result i32) + local.get $root + local.set $root|12 + local.get $fl + local.set $fl|13 + local.get $slMap + i32.ctz + local.set $sl|14 + local.get $root|12 + local.get $fl|13 + i32.const 4 + i32.shl + local.get $sl|14 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.2 + end + local.set $head + end + else + block $~lib/rt/tlsf/GETHEAD|inlined.3 (result i32) + local.get $root + local.set $root|15 + local.get $fl + local.set $fl|16 + local.get $slMap + i32.ctz + local.set $sl|17 + local.get $root|15 + local.get $fl|16 + i32.const 4 + i32.shl + local.get $sl|17 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.3 + end + local.set $head + end + local.get $head + return + ) + (func $~lib/rt/tlsf/growMemory (param $root i32) (param $size i32) + (local $pagesBefore i32) + (local $root|3 i32) + (local $pagesNeeded i32) + (local $5 i32) + (local $6 i32) + (local $pagesWanted i32) + (local $pagesAfter i32) + i32.const 0 + drop + local.get $size + i32.const 256 + i32.ge_u + if + local.get $size + call $~lib/rt/tlsf/roundSize + local.set $size + end + memory.size + local.set $pagesBefore + local.get $size + i32.const 4 + local.get $pagesBefore + i32.const 16 + i32.shl + i32.const 4 + i32.sub + block $~lib/rt/tlsf/GETTAIL|inlined.1 (result i32) + local.get $root + local.set $root|3 + local.get $root|3 + i32.load offset=1568 + br $~lib/rt/tlsf/GETTAIL|inlined.1 + end + i32.ne + i32.shl + i32.add + local.set $size + local.get $size + i32.const 65535 + i32.add + i32.const 65535 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.shr_u + local.set $pagesNeeded + local.get $pagesBefore + local.tee $5 + local.get $pagesNeeded + local.tee $6 + local.get $5 + local.get $6 + i32.gt_s + select + local.set $pagesWanted + local.get $pagesWanted + memory.grow + i32.const 0 + i32.lt_s + if + local.get $pagesNeeded + memory.grow + i32.const 0 + i32.lt_s + if + unreachable + end + end + memory.size + local.set $pagesAfter + local.get $root + local.get $pagesBefore + i32.const 16 + i32.shl + local.get $pagesAfter + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + drop + ) + (func $~lib/rt/tlsf/prepareBlock (param $root i32) (param $block i32) (param $size i32) + (local $blockInfo i32) + (local $remaining i32) + (local $spare i32) + (local $block|6 i32) + (local $block|7 i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $size + i32.const 4 + i32.add + i32.const 15 + i32.and + i32.eqz + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 361 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $size + i32.sub + local.set $remaining + local.get $remaining + i32.const 4 + i32.const 12 + i32.add + i32.ge_u + if + local.get $block + local.get $size + local.get $blockInfo + i32.const 2 + i32.and + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $block + i32.const 4 + i32.add + local.get $size + i32.add + local.set $spare + local.get $spare + local.get $remaining + i32.const 4 + i32.sub + i32.const 1 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.get $spare + call $~lib/rt/tlsf/insertBlock + else + local.get $block + local.get $blockInfo + i32.const 1 + i32.const -1 + i32.xor + i32.and + call $~lib/rt/common/BLOCK#set:mmInfo + block $~lib/rt/tlsf/GETRIGHT|inlined.3 (result i32) + local.get $block + local.set $block|7 + local.get $block|7 + i32.const 4 + i32.add + local.get $block|7 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.3 + end + block $~lib/rt/tlsf/GETRIGHT|inlined.2 (result i32) + local.get $block + local.set $block|6 + local.get $block|6 + i32.const 4 + i32.add + local.get $block|6 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.2 + end + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 2 + i32.const -1 + i32.xor + i32.and + call $~lib/rt/common/BLOCK#set:mmInfo + end + ) + (func $~lib/rt/tlsf/allocateBlock (param $root i32) (param $size i32) (result i32) + (local $payloadSize i32) + (local $block i32) + local.get $size + call $~lib/rt/tlsf/prepareSize + local.set $payloadSize + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/searchBlock + local.set $block + local.get $block + i32.eqz + if + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/growMemory + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/searchBlock + local.set $block + i32.const 1 + drop + local.get $block + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 499 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + end + i32.const 1 + drop + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $payloadSize + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 501 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $root + local.get $block + call $~lib/rt/tlsf/removeBlock + local.get $root + local.get $block + local.get $payloadSize + call $~lib/rt/tlsf/prepareBlock + i32.const 0 + drop + local.get $block + return + ) + (func $~lib/rt/tlsf/__alloc (param $size i32) (result i32) + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $size + call $~lib/rt/tlsf/allocateBlock + i32.const 4 + i32.add + return + ) + (func $~lib/rt/itcms/Object#set:rtId (param $this i32) (param $rtId i32) + local.get $this + local.get $rtId + i32.store offset=12 + ) + (func $~lib/rt/itcms/Object#set:rtSize (param $this i32) (param $rtSize i32) + local.get $this + local.get $rtSize + i32.store offset=16 + ) + (func $~lib/rt/itcms/__new (param $size i32) (param $id i32) (result i32) + (local $obj i32) + (local $ptr i32) + local.get $size + i32.const 1073741804 + i32.ge_u + if + i32.const 288 + i32.const 352 + i32.const 261 + i32.const 31 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.ge_u + if + call $~lib/rt/itcms/interrupt + end + i32.const 16 + local.get $size + i32.add + call $~lib/rt/tlsf/__alloc + i32.const 4 + i32.sub + local.set $obj + local.get $obj + local.get $id + call $~lib/rt/itcms/Object#set:rtId + local.get $obj + local.get $size + call $~lib/rt/itcms/Object#set:rtSize + local.get $obj + global.get $~lib/rt/itcms/fromSpace + global.get $~lib/rt/itcms/white + call $~lib/rt/itcms/Object#linkTo + global.get $~lib/rt/itcms/total + local.get $obj + call $~lib/rt/itcms/Object#get:size + i32.add + global.set $~lib/rt/itcms/total + local.get $obj + i32.const 20 + i32.add + local.set $ptr + local.get $ptr + i32.const 0 + local.get $size + memory.fill + local.get $ptr + return + ) + (func $assembly/arguments/Args#set:a (param $this i32) (param $a i32) + local.get $this + local.get $a + i32.store + ) + (func $assembly/arguments/Args#set:b (param $this i32) (param $b i32) + local.get $this + local.get $b + i32.store offset=4 + ) + (func $assembly/arguments/Args#set:c (param $this i32) (param $c i32) + local.get $this + local.get $c + i32.store offset=8 + ) + (func $assembly/arguments/Args#set:d (param $this i32) (param $d i32) + local.get $this + local.get $d + i32.store offset=12 + ) + (func $start:assembly/arguments~anonymous|0 (param $_d i32) (param $_l i32) (result i32) + i32.const 0 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + return + ) + (func $~lib/arraybuffer/ArrayBufferView#get:byteLength (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/arraybuffer/ArrayBufferView#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/itcms/__link (param $parentPtr i32) (param $childPtr i32) (param $expectMultiple i32) + (local $child i32) + (local $parent i32) + (local $parentColor i32) + local.get $childPtr + i32.eqz + if + return + end + i32.const 1 + drop + local.get $parentPtr + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 295 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $childPtr + i32.const 20 + i32.sub + local.set $child + local.get $child + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eq + if + local.get $parentPtr + i32.const 20 + i32.sub + local.set $parent + local.get $parent + call $~lib/rt/itcms/Object#get:color + local.set $parentColor + local.get $parentColor + global.get $~lib/rt/itcms/white + i32.eqz + i32.eq + if + local.get $expectMultiple + if + local.get $parent + call $~lib/rt/itcms/Object#makeGray + else + local.get $child + call $~lib/rt/itcms/Object#makeGray + end + else + local.get $parentColor + i32.const 3 + i32.eq + if (result i32) + global.get $~lib/rt/itcms/state + i32.const 1 + i32.eq + else + i32.const 0 + end + if + local.get $child + call $~lib/rt/itcms/Object#makeGray + end + end + end + ) + (func $~lib/arraybuffer/ArrayBufferView#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/arguments/Nibbles#set:low (param $this i32) (param $low i32) + local.get $this + local.get $low + i32.store8 + ) + (func $assembly/arguments/Nibbles#set:hig (param $this i32) (param $hig i32) + local.get $this + local.get $hig + i32.store8 offset=1 + ) + (func $assembly/arguments/Nibbles#get:low (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/arguments/Nibbles#get:hig (param $this i32) (result i32) + local.get $this + i32.load8_u offset=1 + ) + (func $assembly/arguments/Args#get:a (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/arguments/Args#get:b (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $start:assembly/arguments + (local $0 i32) + (local $1 i32) + (local $2 i32) + memory.size + i32.const 16 + i32.shl + global.get $~lib/memory/__heap_base + i32.sub + i32.const 1 + i32.shr_u + global.set $~lib/rt/itcms/threshold + i32.const 400 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/pinSpace + i32.const 432 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/toSpace + i32.const 576 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/fromSpace + ) + (func $assembly/instructions/Instruction#set:namePtr (param $this i32) (param $namePtr i32) + local.get $this + local.get $namePtr + i32.store + ) + (func $assembly/instructions/Instruction#set:kind (param $this i32) (param $kind i32) + local.get $this + local.get $kind + i32.store offset=4 + ) + (func $assembly/instructions/Instruction#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=8 + ) + (func $assembly/instructions/Instruction#set:isTerminating (param $this i32) (param $isTerminating i32) + local.get $this + local.get $isTerminating + i32.store8 offset=16 + ) + (func $assembly/instructions/Instruction#constructor (param $this i32) (result i32) + local.get $this + i32.eqz + if + i32.const 17 + call $~lib/rt/tlsf/__alloc + local.set $this + end + local.get $this + i32.const 0 + call $assembly/instructions/Instruction#set:namePtr + local.get $this + global.get $assembly/arguments/Arguments.Zero + call $assembly/instructions/Instruction#set:kind + local.get $this + i64.const 0 + call $assembly/instructions/Instruction#set:gas + local.get $this + i32.const 0 + call $assembly/instructions/Instruction#set:isTerminating + local.get $this + ) + (func $assembly/instructions/instruction (param $name i32) (param $kind i32) (param $gas i64) (param $isTerminating i32) (result i32) + (local $i i32) + i32.const 0 + call $assembly/instructions/Instruction#constructor + local.set $i + local.get $i + local.get $name + call $assembly/instructions/Instruction#set:namePtr + local.get $i + local.get $kind + call $assembly/instructions/Instruction#set:kind + local.get $i + local.get $gas + call $assembly/instructions/Instruction#set:gas + local.get $i + local.get $isTerminating + call $assembly/instructions/Instruction#set:isTerminating + local.get $i + return + ) + (func $~lib/rt/__newBuffer (param $size i32) (param $id i32) (param $data i32) (result i32) + (local $buffer i32) + local.get $size + local.get $id + call $~lib/rt/itcms/__new + local.set $buffer + local.get $data + if + local.get $buffer + local.get $data + local.get $size + memory.copy + end + local.get $buffer + return + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/rt/itcms/Object#get:rtSize (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $~lib/rt/itcms/__renew (param $oldPtr i32) (param $size i32) (result i32) + (local $oldObj i32) + (local $newPtr i32) + (local $4 i32) + (local $5 i32) + local.get $oldPtr + i32.const 20 + i32.sub + local.set $oldObj + local.get $size + local.get $oldObj + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.sub + i32.le_u + if + local.get $oldObj + local.get $size + call $~lib/rt/itcms/Object#set:rtSize + local.get $oldPtr + return + end + local.get $size + local.get $oldObj + call $~lib/rt/itcms/Object#get:rtId + call $~lib/rt/itcms/__new + local.set $newPtr + local.get $newPtr + local.get $oldPtr + local.get $size + local.tee $4 + local.get $oldObj + call $~lib/rt/itcms/Object#get:rtSize + local.tee $5 + local.get $4 + local.get $5 + i32.lt_u + select + memory.copy + local.get $newPtr + return + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/math/ipow32 (param $x i32) (param $e i32) (result i32) + (local $out i32) + (local $log i32) + (local $4 i32) + i32.const 1 + local.set $out + i32.const 0 + i32.const 1 + i32.lt_s + drop + local.get $x + i32.const 2 + i32.eq + if + i32.const 1 + local.get $e + i32.shl + i32.const 0 + local.get $e + i32.const 32 + i32.lt_u + select + return + end + local.get $e + i32.const 0 + i32.le_s + if + local.get $x + i32.const -1 + i32.eq + if + i32.const -1 + i32.const 1 + local.get $e + i32.const 1 + i32.and + select + return + end + local.get $e + i32.const 0 + i32.eq + local.get $x + i32.const 1 + i32.eq + i32.or + return + else + local.get $e + i32.const 1 + i32.eq + if + local.get $x + return + else + local.get $e + i32.const 2 + i32.eq + if + local.get $x + local.get $x + i32.mul + return + else + local.get $e + i32.const 32 + i32.lt_s + if + i32.const 32 + local.get $e + i32.clz + i32.sub + local.set $log + block $break|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $log + local.set $4 + local.get $4 + i32.const 5 + i32.eq + br_if $case0|0 + local.get $4 + i32.const 4 + i32.eq + br_if $case1|0 + local.get $4 + i32.const 3 + i32.eq + br_if $case2|0 + local.get $4 + i32.const 2 + i32.eq + br_if $case3|0 + local.get $4 + i32.const 1 + i32.eq + br_if $case4|0 + br $break|0 + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + end + local.get $out + return + end + end + end + end + loop $while-continue|1 + local.get $e + if + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + br $while-continue|1 + end + end + local.get $out + return + ) + (func $start:assembly/memory-page + i32.const 2 + i32.const 16 + call $~lib/math/ipow32 + global.set $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/PAGE_SIZE + i32.div_u + global.set $assembly/memory-page/RESERVED_PAGES + i32.const 2 + i32.const 29 + call $~lib/math/ipow32 + global.set $assembly/memory-page/ALLOCATE_EAGERLY + ) + (func $assembly/memory/MaybePageFault#set:isFault (param $this i32) (param $isFault i32) + local.get $this + local.get $isFault + i32.store8 + ) + (func $assembly/memory/MaybePageFault#set:isAccess (param $this i32) (param $isAccess i32) + local.get $this + local.get $isAccess + i32.store8 offset=1 + ) + (func $assembly/memory/MaybePageFault#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store offset=4 + ) + (func $~lib/arraybuffer/ArrayBufferView#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/arraybuffer/ArrayBufferView#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/arraybuffer/ArrayBufferView#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $assembly/memory-page/Page#set:access (param $this i32) (param $access i32) + local.get $this + local.get $access + i32.store + ) + (func $assembly/memory-page/Page#set:raw (param $this i32) (param $raw i32) + local.get $this + local.get $raw + i32.store offset=4 + local.get $this + local.get $raw + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory-page/RawPage#set:id (param $this i32) (param $id i32) + local.get $this + local.get $id + i32.store + ) + (func $assembly/memory-page/RawPage#set:page (param $this i32) (param $page i32) + local.get $this + local.get $page + i32.store offset=4 + local.get $this + local.get $page + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $start:assembly/instructions/outcome + call $start:assembly/memory + ) + (func $assembly/instructions/utils/reg (param $v i64) (result i32) + local.get $v + global.get $assembly/registers/NO_OF_REGISTERS + i64.extend_i32_s + i64.ge_u + if (result i32) + global.get $assembly/registers/NO_OF_REGISTERS + i32.const 1 + i32.sub + else + local.get $v + i32.wrap_i64 + end + return + ) + (func $~lib/rt/common/OBJECT#get:rtSize (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 3 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i64) + local.get $this + local.get $index + i32.const 3 + i32.shl + i32.add + local.get $value + i64.store + i32.const 0 + drop + ) + (func $assembly/instructions/outcome/OutcomeData#set:outcome (param $this i32) (param $outcome i32) + local.get $this + local.get $outcome + i32.store + ) + (func $assembly/instructions/outcome/OutcomeData#set:staticJump (param $this i32) (param $staticJump i32) + local.get $this + local.get $staticJump + i32.store offset=4 + ) + (func $assembly/instructions/outcome/OutcomeData#set:dJump (param $this i32) (param $dJump i32) + local.get $this + local.get $dJump + i32.store offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#set:result (param $this i32) (param $result i32) + local.get $this + local.get $result + i32.store offset=12 + ) + (func $assembly/instructions/outcome/OutcomeData#set:exitCode (param $this i32) (param $exitCode i32) + local.get $this + local.get $exitCode + i32.store offset=16 + ) + (func $assembly/instructions/outcome/ok (result i32) + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + return + ) + (func $assembly/instructions/utils/u8SignExtend (param $v i32) (result i64) + local.get $v + i32.extend8_s + i64.extend_i32_s + return + ) + (func $assembly/instructions/utils/u16SignExtend (param $v i32) (result i64) + local.get $v + i32.extend16_s + i64.extend_i32_s + return + ) + (func $~lib/polyfills/bswap (param $value i64) (result i64) + (local $a i64) + (local $b i64) + (local $v i64) + i32.const 1 + drop + i32.const 8 + i32.const 1 + i32.eq + drop + i32.const 8 + i32.const 2 + i32.eq + drop + i32.const 8 + i32.const 4 + i32.eq + drop + i32.const 8 + i32.const 8 + i32.eq + drop + local.get $value + i64.const 8 + i64.shr_u + i64.const 71777214294589695 + i64.and + local.set $a + local.get $value + i64.const 71777214294589695 + i64.and + i64.const 8 + i64.shl + local.set $b + local.get $a + local.get $b + i64.or + local.set $v + local.get $v + i64.const 16 + i64.shr_u + i64.const 281470681808895 + i64.and + local.set $a + local.get $v + i64.const 281470681808895 + i64.and + i64.const 16 + i64.shl + local.set $b + local.get $a + local.get $b + i64.or + i64.const 32 + i64.rotr + return + ) + (func $start:assembly/instructions/bit + call $start:assembly/instructions/outcome + ) + (func $assembly/instructions/utils/u32SignExtend (param $v i32) (result i64) + local.get $v + i64.extend_i32_s + return + ) + (func $assembly/arguments/Args#get:c (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/arguments/Args#get:d (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/memory/Chunks#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#set:first (param $this i32) (param $first i32) + local.get $this + local.get $first + i32.store offset=4 + local.get $this + local.get $first + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#set:second (param $this i32) (param $second i32) + local.get $this + local.get $second + i32.store offset=8 + local.get $this + local.get $second + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Memory#get:pages (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/util/hash/HASH (param $key i32) (result i32) + (local $key|1 i32) + (local $len i32) + (local $h i32) + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 4 + i32.const 4 + i32.le_u + drop + block $~lib/util/hash/hash32|inlined.0 (result i32) + local.get $key + local.set $key|1 + i32.const 4 + local.set $len + i32.const 0 + i32.const 374761393 + i32.add + local.get $len + i32.add + local.set $h + local.get $h + local.get $key|1 + i32.const -1028477379 + i32.mul + i32.add + local.set $h + local.get $h + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 15 + i32.shr_u + i32.xor + local.set $h + local.get $h + i32.const -2048144777 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 13 + i32.shr_u + i32.xor + local.set $h + local.get $h + i32.const -1028477379 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 16 + i32.shr_u + i32.xor + local.set $h + local.get $h + br $~lib/util/hash/hash32|inlined.0 + end + return + ) + (func $"~lib/map/Map#get:buckets" (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $"~lib/map/Map#get:bucketsMask" (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $"~lib/map/MapEntry#get:taggedNext" (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#get:key" (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/PageData#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/PageData#set:page (param $this i32) (param $page i32) + local.get $this + local.get $page + i32.store offset=4 + local.get $this + local.get $page + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/PageData#set:relativeAddress (param $this i32) (param $relativeAddress i32) + local.get $this + local.get $relativeAddress + i32.store offset=8 + ) + (func $"~lib/map/MapEntry#get:value" (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Page#get:access (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/PageData#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/MaybePageFault#get:isFault (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/memory/PageData#get:page (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/PageData#get:relativeAddress (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/memory-page/Page#get:raw (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/RawPage#get:page (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i32) (param $start i32) (param $end i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + local.get $start + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $start + i32.add + local.tee $5 + i32.const 0 + local.tee $6 + local.get $5 + local.get $6 + i32.gt_u + select + else + local.get $start + local.tee $7 + local.get $len + local.tee $8 + local.get $7 + local.get $8 + i32.lt_s + select + end + local.set $start + local.get $end + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $end + i32.add + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_u + select + else + local.get $end + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + end + local.set $end + i32.const 1 + i32.const 1 + i32.eq + drop + local.get $start + local.get $end + i32.lt_s + if + local.get $ptr + local.get $start + i32.add + local.get $value + local.get $end + local.get $start + i32.sub + memory.fill + end + ) + (func $assembly/memory/Chunks#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/ChunkBytes#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/ChunkBytes#set:bytes (param $this i32) (param $bytes i32) + local.get $this + local.get $bytes + i32.store offset=4 + local.get $this + local.get $bytes + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#get:first (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/Chunks#get:second (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 0 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + i32.const 0 + drop + ) + (func $assembly/memory/Result#set:ok (param $this i32) (param $ok i64) + local.get $this + local.get $ok + i64.store + ) + (func $assembly/memory/Result#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store offset=8 + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/ChunkBytes#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/ChunkBytes#get:bytes (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/Result#get:fault (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/memory/Result#get:ok (param $this i32) (result i64) + local.get $this + i64.load + ) + (func $assembly/memory/MaybePageFault#get:isAccess (param $this i32) (result i32) + local.get $this + i32.load8_u offset=1 + ) + (func $assembly/memory/MaybePageFault#get:fault (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/math/ipow64 (param $x i64) (param $e i64) (result i64) + (local $out i64) + (local $log i32) + (local $4 i32) + i64.const 1 + local.set $out + i32.const 0 + i32.const 1 + i32.lt_s + drop + local.get $x + i64.const 2 + i64.eq + if + i64.const 1 + local.get $e + i64.shl + i64.const 0 + local.get $e + i64.const 64 + i64.lt_u + select + return + end + local.get $e + i64.const 0 + i64.le_s + if + local.get $x + i64.const -1 + i64.eq + if + i64.const -1 + i64.const 1 + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + select + return + end + local.get $e + i64.const 0 + i64.eq + i64.extend_i32_u + local.get $x + i64.const 1 + i64.eq + i64.extend_i32_u + i64.or + return + else + local.get $e + i64.const 1 + i64.eq + if + local.get $x + return + else + local.get $e + i64.const 2 + i64.eq + if + local.get $x + local.get $x + i64.mul + return + else + local.get $e + i64.const 64 + i64.lt_s + if + i32.const 64 + local.get $e + i64.clz + i32.wrap_i64 + i32.sub + local.set $log + block $break|0 + block $case5|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $log + local.set $4 + local.get $4 + i32.const 6 + i32.eq + br_if $case0|0 + local.get $4 + i32.const 5 + i32.eq + br_if $case1|0 + local.get $4 + i32.const 4 + i32.eq + br_if $case2|0 + local.get $4 + i32.const 3 + i32.eq + br_if $case3|0 + local.get $4 + i32.const 2 + i32.eq + br_if $case4|0 + local.get $4 + i32.const 1 + i32.eq + br_if $case5|0 + br $break|0 + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + end + local.get $out + return + end + end + end + end + loop $while-continue|1 + local.get $e + i64.const 0 + i64.ne + if + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + br $while-continue|1 + end + end + local.get $out + return + ) + (func $assembly/instructions/utils/mulUpperUnsigned (param $a i64) (param $b i64) (result i64) + (local $aHigh i64) + (local $aLow i64) + (local $bHigh i64) + (local $bLow i64) + (local $lowLow i64) + (local $lowHigh i64) + (local $highLow i64) + (local $highHigh i64) + (local $carry i64) + local.get $a + i64.const 32 + i64.shr_u + local.set $aHigh + local.get $a + i64.const 4294967295 + i64.and + local.set $aLow + local.get $b + i64.const 32 + i64.shr_u + local.set $bHigh + local.get $b + i64.const 4294967295 + i64.and + local.set $bLow + local.get $aLow + local.get $bLow + i64.mul + local.set $lowLow + local.get $aLow + local.get $bHigh + i64.mul + local.set $lowHigh + local.get $aHigh + local.get $bLow + i64.mul + local.set $highLow + local.get $aHigh + local.get $bHigh + i64.mul + local.set $highHigh + local.get $lowLow + i64.const 32 + i64.shr_u + local.get $lowHigh + i64.const 4294967295 + i64.and + i64.add + local.get $highLow + i64.const 4294967295 + i64.and + i64.add + local.set $carry + local.get $highHigh + local.get $lowHigh + i64.const 32 + i64.shr_u + i64.add + local.get $highLow + i64.const 32 + i64.shr_u + i64.add + local.get $carry + i64.const 32 + i64.shr_u + i64.add + return + ) + (func $assembly/instructions/utils/mulUpperSigned (param $a i64) (param $b i64) (result i64) + (local $isResultNegative i32) + (local $aAbs i64) + (local $bAbs i64) + (local $upper i64) + (local $lower i64) + i32.const 0 + local.set $isResultNegative + local.get $a + local.set $aAbs + local.get $b + local.set $bAbs + local.get $a + i64.const 0 + i64.lt_s + if + local.get $isResultNegative + i32.eqz + local.set $isResultNegative + local.get $a + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $aAbs + end + local.get $b + i64.const 0 + i64.lt_s + if + local.get $isResultNegative + i32.eqz + local.set $isResultNegative + local.get $b + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $bAbs + end + local.get $isResultNegative + if + local.get $aAbs + local.get $bAbs + call $assembly/instructions/utils/mulUpperUnsigned + local.set $upper + local.get $aAbs + local.get $bAbs + i64.mul + local.set $lower + local.get $upper + i64.const -1 + i64.xor + local.get $lower + i64.const 0 + i64.eq + if (result i64) + i64.const 1 + else + i64.const 0 + end + i64.add + return + end + local.get $aAbs + local.get $bAbs + call $assembly/instructions/utils/mulUpperUnsigned + return + ) + (func $assembly/instructions/utils/mulUpperSignedUnsigned (param $a i64) (param $b i64) (result i64) + (local $aAbs i64) + (local $upper i64) + (local $lower i64) + local.get $a + i64.const 0 + i64.lt_s + if + local.get $a + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $aAbs + local.get $aAbs + local.get $b + call $assembly/instructions/utils/mulUpperUnsigned + local.set $upper + local.get $aAbs + local.get $b + i64.mul + local.set $lower + local.get $upper + i64.const -1 + i64.xor + local.get $lower + i64.const 0 + i64.eq + if (result i64) + i64.const 1 + else + i64.const 0 + end + i64.add + return + end + local.get $a + local.get $b + call $assembly/instructions/utils/mulUpperUnsigned + return + ) + (func $assembly/instructions/rot/math.rot_r (param $v i64) (param $shift i64) (result i64) + local.get $v + local.get $shift + i64.rotr + return + ) + (func $assembly/instructions/rot/math.rot_r_32 (param $v i32) (param $shift i32) (result i32) + local.get $v + local.get $shift + i32.rotr + return + ) + (func $assembly/instructions/rot/math.rot_l (param $v i64) (param $shift i64) (result i64) + local.get $v + local.get $shift + i64.rotl + return + ) + (func $assembly/instructions/rot/math.rot_l_32 (param $v i32) (param $shift i32) (result i32) + local.get $v + local.get $shift + i32.rotl + return + ) + (func $assembly/instructions/outcome/panic (result i32) + global.get $assembly/instructions/outcome/Result.PANIC + call $assembly/instructions/outcome/status + return + ) + (func $start:assembly/instructions/misc~anonymous|0 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/panic + ) + (func $start:assembly/instructions/misc~anonymous|1 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/panic + ) + (func $start:assembly/instructions/misc~anonymous|2 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/ok + ) + (func $assembly/memory/Memory#get:sbrkAddress (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/memory/Memory#set:sbrkAddress (param $this i32) (param $sbrkAddress i32) + local.get $this + local.get $sbrkAddress + i32.store offset=12 + ) + (func $assembly/memory/Memory#get:lastAllocatedPage (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/Memory#get:arena (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Arena#get:free (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $assembly/memory-page/Arena#get:extraPageIndex (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/memory-page/Arena#get:arenaBytes (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Arena#set:extraPageIndex (param $this i32) (param $extraPageIndex i32) + local.get $this + local.get $extraPageIndex + i32.store offset=8 + ) + (func $"~lib/map/MapEntry#set:value" (param $this i32) (param $value i32) + local.get $this + local.get $value + i32.store offset=4 + ) + (func $"~lib/map/Map#get:entriesOffset" (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $"~lib/map/Map#get:entriesCapacity" (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $"~lib/map/Map#get:entriesCount" (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $"~lib/map/Map#get:entries" (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#set:key" (param $this i32) (param $key i32) + local.get $this + local.get $key + i32.store + ) + (func $"~lib/map/MapEntry#set:taggedNext" (param $this i32) (param $taggedNext i32) + local.get $this + local.get $taggedNext + i32.store offset=8 + ) + (func $"~lib/map/Map#set:buckets" (param $this i32) (param $buckets i32) + local.get $this + local.get $buckets + i32.store + local.get $this + local.get $buckets + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $"~lib/map/Map#set:bucketsMask" (param $this i32) (param $bucketsMask i32) + local.get $this + local.get $bucketsMask + i32.store offset=4 + ) + (func $"~lib/map/Map#set:entries" (param $this i32) (param $entries i32) + local.get $this + local.get $entries + i32.store offset=8 + local.get $this + local.get $entries + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $"~lib/map/Map#set:entriesCapacity" (param $this i32) (param $entriesCapacity i32) + local.get $this + local.get $entriesCapacity + i32.store offset=12 + ) + (func $"~lib/map/Map#set:entriesOffset" (param $this i32) (param $entriesOffset i32) + local.get $this + local.get $entriesOffset + i32.store offset=16 + ) + (func $"~lib/map/Map#set:entriesCount" (param $this i32) (param $entriesCount i32) + local.get $this + local.get $entriesCount + i32.store offset=20 + ) + (func $assembly/memory/Memory#set:lastAllocatedPage (param $this i32) (param $lastAllocatedPage i32) + local.get $this + local.get $lastAllocatedPage + i32.store + ) + (func $start:assembly/instructions-exe + (local $0 i32) + call $start:assembly/instructions/bit + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $start:assembly/interpreter + call $start:assembly/instructions-exe + i64.const 2 + i64.const 32 + call $~lib/math/ipow64 + global.set $assembly/interpreter/MAX_U32 + ) + (func $start:assembly/api-generic + call $start:assembly/arguments + call $start:assembly/instructions + call $start:assembly/interpreter + ) + (func $start:assembly/index + call $start:assembly/api-generic + ) + (func $assembly/codec/Decoder#set:source (param $this i32) (param $source i32) + local.get $this + local.get $source + i32.store + local.get $this + local.get $source + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/codec/Decoder#set:offset (param $this i32) (param $offset i32) + local.get $this + local.get $offset + i32.store offset=4 + ) + (func $assembly/codec/Decoder#get:offset (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/codec/Decoder#get:source (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/util/number/decimalCount32 (param $value i32) (result i32) + local.get $value + i32.const 100000 + i32.lt_u + if + local.get $value + i32.const 100 + i32.lt_u + if + i32.const 1 + local.get $value + i32.const 10 + i32.ge_u + i32.add + return + else + i32.const 3 + local.get $value + i32.const 10000 + i32.ge_u + i32.add + local.get $value + i32.const 1000 + i32.ge_u + i32.add + return + end + unreachable + else + local.get $value + i32.const 10000000 + i32.lt_u + if + i32.const 6 + local.get $value + i32.const 1000000 + i32.ge_u + i32.add + return + else + i32.const 8 + local.get $value + i32.const 1000000000 + i32.ge_u + i32.add + local.get $value + i32.const 100000000 + i32.ge_u + i32.add + return + end + unreachable + end + unreachable + ) + (func $~lib/util/number/utoa32_dec_lut (param $buffer i32) (param $num i32) (param $offset i32) + (local $t i32) + (local $r i32) + (local $d1 i32) + (local $d2 i32) + (local $digits1 i64) + (local $digits2 i64) + (local $t|9 i32) + (local $d1|10 i32) + (local $digits i32) + (local $digits|12 i32) + (local $digit i32) + loop $while-continue|0 + local.get $num + i32.const 10000 + i32.ge_u + if + local.get $num + i32.const 10000 + i32.div_u + local.set $t + local.get $num + i32.const 10000 + i32.rem_u + local.set $r + local.get $t + local.set $num + local.get $r + i32.const 100 + i32.div_u + local.set $d1 + local.get $r + i32.const 100 + i32.rem_u + local.set $d2 + i32.const 14812 + local.get $d1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 14812 + local.get $d2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $num + i32.const 100 + i32.ge_u + if + local.get $num + i32.const 100 + i32.div_u + local.set $t|9 + local.get $num + i32.const 100 + i32.rem_u + local.set $d1|10 + local.get $t|9 + local.set $num + local.get $offset + i32.const 2 + i32.sub + local.set $offset + i32.const 14812 + local.get $d1|10 + i32.const 2 + i32.shl + i32.add + i32.load + local.set $digits + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits + i32.store + end + local.get $num + i32.const 10 + i32.ge_u + if + local.get $offset + i32.const 2 + i32.sub + local.set $offset + i32.const 14812 + local.get $num + i32.const 2 + i32.shl + i32.add + i32.load + local.set $digits|12 + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits|12 + i32.store + else + local.get $offset + i32.const 1 + i32.sub + local.set $offset + i32.const 48 + local.get $num + i32.add + local.set $digit + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digit + i32.store16 + end + ) + (func $~lib/util/number/utoa_hex_lut (param $buffer i32) (param $num i64) (param $offset i32) + loop $while-continue|0 + local.get $offset + i32.const 2 + i32.ge_u + if + local.get $offset + i32.const 2 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 15232 + local.get $num + i32.wrap_i64 + i32.const 255 + i32.and + i32.const 2 + i32.shl + i32.add + i32.load + i32.store + local.get $num + i64.const 8 + i64.shr_u + local.set $num + br $while-continue|0 + end + end + local.get $offset + i32.const 1 + i32.and + if + local.get $buffer + i32.const 15232 + local.get $num + i32.wrap_i64 + i32.const 6 + i32.shl + i32.add + i32.load16_u + i32.store16 + end + ) + (func $~lib/util/number/ulog_base (param $num i64) (param $base i32) (result i32) + (local $value i32) + (local $b64 i64) + (local $b i64) + (local $e i32) + block $~lib/util/number/isPowerOf2|inlined.0 (result i32) + local.get $base + local.set $value + local.get $value + i32.popcnt + i32.const 1 + i32.eq + br $~lib/util/number/isPowerOf2|inlined.0 + end + if + i32.const 63 + local.get $num + i64.clz + i32.wrap_i64 + i32.sub + i32.const 31 + local.get $base + i32.clz + i32.sub + i32.div_u + i32.const 1 + i32.add + return + end + local.get $base + i64.extend_i32_s + local.set $b64 + local.get $b64 + local.set $b + i32.const 1 + local.set $e + loop $while-continue|0 + local.get $num + local.get $b + i64.ge_u + if + local.get $num + local.get $b + i64.div_u + local.set $num + local.get $b + local.get $b + i64.mul + local.set $b + local.get $e + i32.const 1 + i32.shl + local.set $e + br $while-continue|0 + end + end + loop $while-continue|1 + local.get $num + i64.const 1 + i64.ge_u + if + local.get $num + local.get $b64 + i64.div_u + local.set $num + local.get $e + i32.const 1 + i32.add + local.set $e + br $while-continue|1 + end + end + local.get $e + i32.const 1 + i32.sub + return + ) + (func $~lib/util/number/utoa64_any_core (param $buffer i32) (param $num i64) (param $offset i32) (param $radix i32) + (local $base i64) + (local $shift i64) + (local $mask i64) + (local $q i64) + local.get $radix + i64.extend_i32_s + local.set $base + local.get $radix + local.get $radix + i32.const 1 + i32.sub + i32.and + i32.const 0 + i32.eq + if + local.get $radix + i32.ctz + i32.const 7 + i32.and + i64.extend_i32_s + local.set $shift + local.get $base + i64.const 1 + i64.sub + local.set $mask + loop $do-loop|0 + local.get $offset + i32.const 1 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 16288 + local.get $num + local.get $mask + i64.and + i32.wrap_i64 + i32.const 1 + i32.shl + i32.add + i32.load16_u + i32.store16 + local.get $num + local.get $shift + i64.shr_u + local.set $num + local.get $num + i64.const 0 + i64.ne + br_if $do-loop|0 + end + else + loop $do-loop|1 + local.get $offset + i32.const 1 + i32.sub + local.set $offset + local.get $num + local.get $base + i64.div_u + local.set $q + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 16288 + local.get $num + local.get $q + local.get $base + i64.mul + i64.sub + i32.wrap_i64 + i32.const 1 + i32.shl + i32.add + i32.load16_u + i32.store16 + local.get $q + local.set $num + local.get $num + i64.const 0 + i64.ne + br_if $do-loop|1 + end + end + ) + (func $~lib/number/U32#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/utoa32 + return + ) + (func $~lib/number/I32#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/itoa32 + return + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/string/String#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 1 + i32.shr_u + return + ) + (func $assembly/codec/ValOffset#set:value (param $this i32) (param $value i32) + local.get $this + local.get $value + i32.store + ) + (func $assembly/codec/ValOffset#set:offset (param $this i32) (param $offset i32) + local.get $this + local.get $offset + i32.store offset=4 + ) + (func $assembly/codec/ValOffset#get:offset (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/codec/ValOffset#get:value (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/CodeAndMetadata#set:code (param $this i32) (param $code i32) + local.get $this + local.get $code + i32.store + local.get $this + local.get $code + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/CodeAndMetadata#set:metadata (param $this i32) (param $metadata i32) + local.get $this + local.get $metadata + i32.store offset=4 + local.get $this + local.get $metadata + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/CodeAndMetadata#get:code (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/CodeAndMetadata#get:metadata (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/number/U8#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + i32.const 255 + i32.and + local.get $radix + call $~lib/util/number/utoa32 + return + ) + (func $~lib/memory/memory.repeat (param $dst i32) (param $src i32) (param $srcLength i32) (param $count i32) + (local $index i32) + (local $total i32) + i32.const 0 + local.set $index + local.get $srcLength + local.get $count + i32.mul + local.set $total + loop $while-continue|0 + local.get $index + local.get $total + i32.lt_u + if + local.get $dst + local.get $index + i32.add + local.get $src + local.get $srcLength + memory.copy + local.get $index + local.get $srcLength + i32.add + local.set $index + br $while-continue|0 + end + end + ) + (func $assembly/program/Mask#set:bytesToSkip (param $this i32) (param $bytesToSkip i32) + local.get $this + local.get $bytesToSkip + i32.store + local.get $this + local.get $bytesToSkip + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Mask#get:bytesToSkip (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + ) + (func $assembly/program/JumpTable#set:jumps (param $this i32) (param $jumps i32) + local.get $this + local.get $jumps + i32.store + local.get $this + local.get $jumps + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + ) + (func $assembly/instructions/Instruction#get:isTerminating (param $this i32) (result i32) + local.get $this + i32.load8_u offset=16 + ) + (func $assembly/program/BasicBlocks#set:isStartOrEnd (param $this i32) (param $isStartOrEnd i32) + local.get $this + local.get $isStartOrEnd + i32.store + local.get $this + local.get $isStartOrEnd + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:code (param $this i32) (param $code i32) + local.get $this + local.get $code + i32.store + local.get $this + local.get $code + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:mask (param $this i32) (param $mask i32) + local.get $this + local.get $mask + i32.store offset=4 + local.get $this + local.get $mask + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:jumpTable (param $this i32) (param $jumpTable i32) + local.get $this + local.get $jumpTable + i32.store offset=8 + local.get $this + local.get $jumpTable + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:basicBlocks (param $this i32) (param $basicBlocks i32) + local.get $this + local.get $basicBlocks + i32.store offset=12 + local.get $this + local.get $basicBlocks + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#get:code (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/Program#get:mask (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/Instruction#get:namePtr (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/instructions/Instruction#get:kind (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i64) (param $start i32) (param $end i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + local.get $start + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $start + i32.add + local.tee $5 + i32.const 0 + local.tee $6 + local.get $5 + local.get $6 + i32.gt_u + select + else + local.get $start + local.tee $7 + local.get $len + local.tee $8 + local.get $7 + local.get $8 + i32.lt_s + select + end + local.set $start + local.get $end + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $end + i32.add + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_u + select + else + local.get $end + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + end + local.set $end + i32.const 8 + i32.const 1 + i32.eq + drop + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 1 + drop + local.get $value + i64.const 0 + i64.eq + local.get $value + i64.const -1 + i64.eq + i32.or + if + local.get $start + local.get $end + i32.lt_s + if + local.get $ptr + local.get $start + i32.const 3 + i32.shl + i32.add + local.get $value + i32.wrap_i64 + local.get $end + local.get $start + i32.sub + i32.const 3 + i32.shl + memory.fill + end + return + end + loop $for-loop|0 + local.get $start + local.get $end + i32.lt_s + if + local.get $ptr + local.get $start + i32.const 3 + i32.shl + i32.add + local.get $value + i64.store + local.get $start + i32.const 1 + i32.add + local.set $start + br $for-loop|0 + end + end + ) + (func $assembly/api-generic/VmInput#set:registers (param $this i32) (param $registers i32) + local.get $this + local.get $registers + i32.store + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmInput#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store offset=4 + ) + (func $assembly/api-generic/VmInput#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=8 + ) + (func $assembly/api-generic/VmInput#set:program (param $this i32) (param $program i32) + local.get $this + local.get $program + i32.store offset=16 + local.get $this + local.get $program + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmInput#set:pageMap (param $this i32) (param $pageMap i32) + local.get $this + local.get $pageMap + i32.store offset=20 + local.get $this + local.get $pageMap + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmInput#set:memory (param $this i32) (param $memory i32) + local.get $this + local.get $memory + i32.store offset=24 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmInput#get:program (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/api-generic/VmInput#get:registers (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/MemoryBuilder#set:pages (param $this i32) (param $pages i32) + local.get $this + local.get $pages + i32.store + local.get $this + local.get $pages + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory-page/Arena#set:arenaBytes (param $this i32) (param $arenaBytes i32) + local.get $this + local.get $arenaBytes + i32.store offset=4 + ) + (func $assembly/memory-page/Arena#set:free (param $this i32) (param $free i32) + local.get $this + local.get $free + i32.store + local.get $this + local.get $free + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/arraybuffer/ArrayBuffer#get:byteLength (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + return + ) + (func $assembly/memory/MemoryBuilder#set:arena (param $this i32) (param $arena i32) + local.get $this + local.get $arena + i32.store offset=4 + local.get $this + local.get $arena + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmInput#get:pageMap (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $assembly/api-generic/VmInput#get:memory (param $this i32) (result i32) + local.get $this + i32.load offset=24 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-generic/InitialPage#get:access (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/api-generic/InitialPage#get:address (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/api-generic/InitialPage#get:length (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/MemoryBuilder#get:pages (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/MemoryBuilder#get:arena (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-generic/InitialChunk#get:data (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-generic/InitialChunk#get:address (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/Memory#set:arena (param $this i32) (param $arena i32) + local.get $this + local.get $arena + i32.store offset=4 + local.get $this + local.get $arena + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Memory#set:pages (param $this i32) (param $pages i32) + local.get $this + local.get $pages + i32.store offset=8 + local.get $this + local.get $pages + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/interpreter/Interpreter#set:program (param $this i32) (param $program i32) + local.get $this + local.get $program + i32.store + local.get $this + local.get $program + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/interpreter/Interpreter#set:registers (param $this i32) (param $registers i32) + local.get $this + local.get $registers + i32.store offset=4 + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/interpreter/Interpreter#set:memory (param $this i32) (param $memory i32) + local.get $this + local.get $memory + i32.store offset=8 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/gas/GasCounterU64#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store + ) + (func $assembly/gas/gasCounter (param $gas i64) (result i32) + i32.const 0 + local.get $gas + call $assembly/gas/GasCounterU64#constructor + return + ) + (func $assembly/interpreter/Interpreter#set:gas (param $this i32) (param $gas i32) + local.get $this + local.get $gas + i32.store offset=12 + local.get $this + local.get $gas + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/interpreter/Interpreter#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store offset=16 + ) + (func $assembly/interpreter/Interpreter#set:status (param $this i32) (param $status i32) + local.get $this + local.get $status + i32.store offset=20 + ) + (func $assembly/interpreter/Interpreter#set:exitCode (param $this i32) (param $exitCode i32) + local.get $this + local.get $exitCode + i32.store offset=24 + ) + (func $assembly/interpreter/Interpreter#set:nextPc (param $this i32) (param $nextPc i32) + local.get $this + local.get $nextPc + i32.store offset=28 + ) + (func $assembly/interpreter/Interpreter#set:useSbrkGas (param $this i32) (param $useSbrkGas i32) + local.get $this + local.get $useSbrkGas + i32.store8 offset=32 + ) + (func $assembly/api-generic/VmInput#get:pc (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/interpreter/Interpreter#get:gas (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/api-generic/VmInput#get:gas (param $this i32) (result i64) + local.get $this + i64.load offset=8 + ) + (func $assembly/gas/GasCounter#set (param $this i32) (param $g i64) + unreachable + ) + (func $~lib/util/number/decimalCount64High (param $value i64) (result i32) + local.get $value + i64.const 1000000000000000 + i64.lt_u + if + local.get $value + i64.const 1000000000000 + i64.lt_u + if + i32.const 10 + local.get $value + i64.const 100000000000 + i64.ge_u + i32.add + local.get $value + i64.const 10000000000 + i64.ge_u + i32.add + return + else + i32.const 13 + local.get $value + i64.const 100000000000000 + i64.ge_u + i32.add + local.get $value + i64.const 10000000000000 + i64.ge_u + i32.add + return + end + unreachable + else + local.get $value + i64.const 100000000000000000 + i64.lt_u + if + i32.const 16 + local.get $value + i64.const 10000000000000000 + i64.ge_u + i32.add + return + else + i32.const 18 + local.get $value + i64.const -8446744073709551616 + i64.ge_u + i32.add + local.get $value + i64.const 1000000000000000000 + i64.ge_u + i32.add + return + end + unreachable + end + unreachable + ) + (func $~lib/util/number/utoa64_dec_lut (param $buffer i32) (param $num i64) (param $offset i32) + (local $t i64) + (local $r i32) + (local $b i32) + (local $c i32) + (local $b1 i32) + (local $b2 i32) + (local $c1 i32) + (local $c2 i32) + (local $digits1 i64) + (local $digits2 i64) + loop $while-continue|0 + local.get $num + i64.const 100000000 + i64.ge_u + if + local.get $num + i64.const 100000000 + i64.div_u + local.set $t + local.get $num + local.get $t + i64.const 100000000 + i64.mul + i64.sub + i32.wrap_i64 + local.set $r + local.get $t + local.set $num + local.get $r + i32.const 10000 + i32.div_u + local.set $b + local.get $r + i32.const 10000 + i32.rem_u + local.set $c + local.get $b + i32.const 100 + i32.div_u + local.set $b1 + local.get $b + i32.const 100 + i32.rem_u + local.set $b2 + local.get $c + i32.const 100 + i32.div_u + local.set $c1 + local.get $c + i32.const 100 + i32.rem_u + local.set $c2 + i32.const 14812 + local.get $c1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 14812 + local.get $c2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + i32.const 14812 + local.get $b1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 14812 + local.get $b2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $buffer + local.get $num + i32.wrap_i64 + local.get $offset + call $~lib/util/number/utoa32_dec_lut + ) + (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i64) (result i32) + (local $sign i32) + (local $dest i32) + (local $decimals i32) + (local $val32 i32) + (local $buffer|6 i32) + (local $num i32) + (local $offset i32) + (local $val64 i64) + (local $buffer|10 i32) + (local $num|11 i64) + (local $offset|12 i32) + i32.const 0 + local.set $sign + i32.const 0 + drop + local.get $buffer + local.get $sign + i32.const 1 + i32.shl + i32.add + local.set $dest + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 0 + drop + local.get $value + i64.const 10 + i64.lt_u + if + local.get $buffer + local.get $value + i32.const 48 + i64.extend_i32_s + i64.or + i64.store16 + i32.const 1 + return + end + i32.const 0 + local.set $decimals + i32.const 8 + i32.const 4 + i32.le_u + drop + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + local.get $dest + local.set $buffer|6 + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|6 + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + local.set $val64 + local.get $val64 + call $~lib/util/number/decimalCount64High + local.set $decimals + local.get $dest + local.set $buffer|10 + local.get $val64 + local.set $num|11 + local.get $decimals + local.set $offset|12 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|10 + local.get $num|11 + local.get $offset|12 + call $~lib/util/number/utoa64_dec_lut + end + local.get $sign + local.get $decimals + i32.add + return + ) + (func $~lib/number/U64#toString (param $this i64) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/utoa64 + return + ) + (func $~lib/array/Array<~lib/string/String>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array<~lib/string/String>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/interpreter/Interpreter#get:status (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $assembly/interpreter/Interpreter#get:pc (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/interpreter/Interpreter#get:program (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/interpreter/Interpreter#get:registers (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/program/ResolvedArguments#set:a (param $this i32) (param $a i64) + local.get $this + local.get $a + i64.store + ) + (func $assembly/program/ResolvedArguments#set:b (param $this i32) (param $b i64) + local.get $this + local.get $b + i64.store offset=8 + ) + (func $assembly/program/ResolvedArguments#set:c (param $this i32) (param $c i64) + local.get $this + local.get $c + i64.store offset=16 + ) + (func $assembly/program/ResolvedArguments#set:d (param $this i32) (param $d i64) + local.get $this + local.get $d + i64.store offset=24 + ) + (func $assembly/program/ResolvedArguments#set:decoded (param $this i32) (param $decoded i32) + local.get $this + local.get $decoded + i32.store offset=32 + local.get $this + local.get $decoded + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/ResolvedArguments#get:a (param $this i32) (result i64) + local.get $this + i64.load + ) + (func $~lib/number/I64#toString (param $this i64) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/itoa64 + return + ) + (func $assembly/program/ResolvedArguments#get:decoded (param $this i32) (result i32) + local.get $this + i32.load offset=32 + ) + (func $assembly/program/ResolvedArguments#get:b (param $this i32) (result i64) + local.get $this + i64.load offset=8 + ) + (func $assembly/program/ResolvedArguments#get:c (param $this i32) (result i64) + local.get $this + i64.load offset=16 + ) + (func $assembly/program/ResolvedArguments#get:d (param $this i32) (result i64) + local.get $this + i64.load offset=24 + ) + (func $assembly/interpreter/Interpreter#get:nextPc (param $this i32) (result i32) + local.get $this + i32.load offset=28 + ) + (func $assembly/instructions/Instruction#get:gas (param $this i32) (result i64) + local.get $this + i64.load offset=8 + ) + (func $assembly/gas/GasCounter#sub (param $this i32) (param $g i64) (result i32) + unreachable + ) + (func $assembly/interpreter/Interpreter#get:useSbrkGas (param $this i32) (result i32) + local.get $this + i32.load8_u offset=32 + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/interpreter/Interpreter#get:memory (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#get:outcome (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/Program#get:jumpTable (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#get:dJump (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/interpreter/DjumpResult#set:status (param $this i32) (param $status i32) + local.get $this + local.get $status + i32.store + ) + (func $assembly/interpreter/DjumpResult#set:newPc (param $this i32) (param $newPc i32) + local.get $this + local.get $newPc + i32.store offset=4 + ) + (func $assembly/program/JumpTable#get:jumps (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/interpreter/DjumpResult#get:status (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/Program#get:basicBlocks (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/interpreter/DjumpResult#get:newPc (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/interpreter/BranchResult#set:isOkay (param $this i32) (param $isOkay i32) + local.get $this + local.get $isOkay + i32.store8 + ) + (func $assembly/interpreter/BranchResult#set:newPc (param $this i32) (param $newPc i32) + local.get $this + local.get $newPc + i32.store offset=4 + ) + (func $assembly/program/BasicBlocks#get:isStartOrEnd (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/interpreter/BranchResult#get:isOkay (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/interpreter/BranchResult#get:newPc (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/outcome/OutcomeData#get:staticJump (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/outcome/OutcomeData#get:result (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/instructions/outcome/OutcomeData#get:exitCode (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/api-generic/VmOutput#set:status (param $this i32) (param $status i32) + local.get $this + local.get $status + i32.store + ) + (func $assembly/api-generic/VmOutput#set:registers (param $this i32) (param $registers i32) + local.get $this + local.get $registers + i32.store offset=4 + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmOutput#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store offset=8 + ) + (func $assembly/api-generic/VmOutput#set:memory (param $this i32) (param $memory i32) + local.get $this + local.get $memory + i32.store offset=12 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmOutput#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=16 + ) + (func $assembly/api-generic/VmOutput#set:exitCode (param $this i32) (param $exitCode i32) + local.get $this + local.get $exitCode + i32.store offset=24 + ) + (func $assembly/gas/GasCounter#get (param $this i32) (result i64) + unreachable + ) + (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $assembly/api-generic/InitialChunk#set:address (param $this i32) (param $address i32) + local.get $this + local.get $address + i32.store + ) + (func $assembly/api-generic/InitialChunk#set:data (param $this i32) (param $data i32) + local.get $this + local.get $data + i32.store offset=4 + local.get $this + local.get $data + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $assembly/interpreter/Interpreter#get:exitCode (param $this i32) (result i32) + local.get $this + i32.load offset=24 + ) + (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-generic/VmOutput#get:status (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 0 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + i32.const 0 + drop + ) + (func $assembly/program-build/immBytes (param $dataLength i32) (param $required i32) (result i32) + (local $value1 f64) + (local $value2 f64) + local.get $dataLength + local.get $required + i32.lt_s + if + i32.const 0 + return + end + block $~lib/math/NativeMath.min|inlined.4 (result f64) + f64.const 4 + local.set $value1 + local.get $dataLength + local.get $required + i32.sub + f64.convert_i32_s + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.4 + end + i32.trunc_sat_f64_s + return + ) + (func $~lib/dataview/DataView#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/dataview/DataView#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/dataview/DataView#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $~lib/dataview/DataView#get:byteLength (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/dataview/DataView#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-generic/InitialPage#set:address (param $this i32) (param $address i32) + local.get $this + local.get $address + i32.store + ) + (func $assembly/api-generic/InitialPage#set:length (param $this i32) (param $length i32) + local.get $this + local.get $length + i32.store offset=4 + ) + (func $assembly/api-generic/InitialPage#set:access (param $this i32) (param $access i32) + local.get $this + local.get $access + i32.store offset=8 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/rt/itcms/__pin (param $ptr i32) (result i32) + (local $obj i32) + local.get $ptr + if + local.get $ptr + i32.const 20 + i32.sub + local.set $obj + local.get $obj + call $~lib/rt/itcms/Object#get:color + i32.const 3 + i32.eq + if + i32.const 19920 + i32.const 352 + i32.const 338 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $obj + call $~lib/rt/itcms/Object#unlink + local.get $obj + global.get $~lib/rt/itcms/pinSpace + i32.const 3 + call $~lib/rt/itcms/Object#linkTo + end + local.get $ptr + return + ) + (func $~lib/rt/itcms/__unpin (param $ptr i32) + (local $obj i32) + local.get $ptr + i32.eqz + if + return + end + local.get $ptr + i32.const 20 + i32.sub + local.set $obj + local.get $obj + call $~lib/rt/itcms/Object#get:color + i32.const 3 + i32.ne + if + i32.const 19984 + i32.const 352 + i32.const 352 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/state + i32.const 1 + i32.eq + if + local.get $obj + call $~lib/rt/itcms/Object#makeGray + else + local.get $obj + call $~lib/rt/itcms/Object#unlink + local.get $obj + global.get $~lib/rt/itcms/fromSpace + global.get $~lib/rt/itcms/white + call $~lib/rt/itcms/Object#linkTo + end + ) + (func $~lib/rt/itcms/__collect + i32.const 0 + drop + global.get $~lib/rt/itcms/state + i32.const 0 + i32.gt_s + if + loop $while-continue|0 + global.get $~lib/rt/itcms/state + i32.const 0 + i32.ne + if + call $~lib/rt/itcms/step + drop + br $while-continue|0 + end + end + end + call $~lib/rt/itcms/step + drop + loop $while-continue|1 + global.get $~lib/rt/itcms/state + i32.const 0 + i32.ne + if + call $~lib/rt/itcms/step + drop + br $while-continue|1 + end + end + global.get $~lib/rt/itcms/total + i64.extend_i32_u + i32.const 200 + i64.extend_i32_u + i64.mul + i64.const 100 + i64.div_u + i32.wrap_i64 + i32.const 1024 + i32.add + global.set $~lib/rt/itcms/threshold + i32.const 0 + drop + i32.const 0 + drop + ) + (func $assembly/gas/GasCounterU64#get:gas (param $this i32) (result i64) + local.get $this + i64.load + ) + (func $assembly/gas/GasCounter#set@override (param $0 i32) (param $1 i64) + (local $2 i32) + block $default + block $case0 + local.get $0 + i32.const 8 + i32.sub + i32.load + local.set $2 + local.get $2 + i32.const 51 + i32.eq + br_if $case0 + br $default + end + local.get $0 + local.get $1 + call $assembly/gas/GasCounterU64#set + return + end + unreachable + ) + (func $assembly/gas/GasCounter#sub@override (param $0 i32) (param $1 i64) (result i32) + (local $2 i32) + block $default + block $case0 + local.get $0 + i32.const 8 + i32.sub + i32.load + local.set $2 + local.get $2 + i32.const 51 + i32.eq + br_if $case0 + br $default + end + local.get $0 + local.get $1 + call $assembly/gas/GasCounterU64#sub + return + end + unreachable + ) + (func $assembly/gas/GasCounter#get@override (param $0 i32) (result i64) + (local $1 i32) + block $default + block $case0 + local.get $0 + i32.const 8 + i32.sub + i32.load + local.set $1 + local.get $1 + i32.const 51 + i32.eq + br_if $case0 + br $default + end + local.get $0 + call $assembly/gas/GasCounterU64#get + return + end + unreachable + ) + (func $~lib/rt/__visit_globals (param $0 i32) + (local $1 i32) + i32.const 480 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 8176 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 13120 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 16800 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 9376 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 288 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 19920 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 19984 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 15232 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 16288 + local.get $0 + call $~lib/rt/itcms/__visit + global.get $assembly/api/interpreter + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/RELEVANT_ARGS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/REQUIRED_BYTES + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/DECODERS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/INSTRUCTIONS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_PAGE + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/codec/MASKS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions-exe/RUN + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + ) + (func $~lib/arraybuffer/ArrayBufferView~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/object/Object~visit (param $0 i32) (param $1 i32) + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/typedarray/Uint8Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/memory-page/Page~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory-page/RawPage~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/Memory~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory-page/Arena~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $"~lib/map/Map~visit" (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $"~lib/map/Map#__visit" + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit + ) + (func $assembly/memory/Result~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/ChunkBytes~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/Chunks~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/PageData~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/function/Function<%28u8%29=>u8>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28u8%29=>u8>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28u8%29=>u8>#__visit + ) + (func $assembly/interpreter/Interpreter~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/Program~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/Mask~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/JumpTable~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/BasicBlocks~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/CodeAndMetadata~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/codec/Decoder~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + i32.const 1 + drop + local.get $this + local.set $cur + local.get $cur + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray<~lib/string/String>#__visit + ) + (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/api-generic/VmOutput~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/api-generic/InitialChunk~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/api-generic/VmInput~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=16 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=20 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=24 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/memory/MemoryBuilder~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array<~lib/string/String>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<~lib/string/String>#__visit + ) + (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit + ) + (func $assembly/program/ResolvedArguments~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=32 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/dataview/DataView~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/rt/__visit_members (param $0 i32) (param $1 i32) + block $invalid + block $~lib/dataview/DataView + block $~lib/staticarray/StaticArray + block $~lib/array/Array + block $assembly/interpreter/BranchResult + block $assembly/interpreter/DjumpResult + block $assembly/program/ResolvedArguments + block $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> + block $~lib/array/Array<~lib/string/String> + block $assembly/gas/GasCounterU64 + block $assembly/memory/MemoryBuilder + block $~lib/array/Array + block $assembly/api-generic/InitialPage + block $assembly/api-generic/VmInput + block $~lib/array/Array + block $assembly/api-generic/InitialChunk + block $assembly/api-generic/VmOutput + block $~lib/array/Array + block $~lib/array/Array + block $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> + block $assembly/codec/ValOffset + block $~lib/staticarray/StaticArray<~lib/string/String> + block $assembly/codec/Decoder + block $assembly/program/CodeAndMetadata + block $assembly/gas/GasCounter + block $~lib/staticarray/StaticArray + block $assembly/program/BasicBlocks + block $assembly/program/JumpTable + block $~lib/staticarray/StaticArray + block $assembly/program/Mask + block $assembly/program/Program + block $assembly/interpreter/Interpreter + block $~lib/function/Function<%28u8%29=>u8> + block $~lib/array/Array + block $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> + block $assembly/memory/PageData + block $assembly/memory/Chunks + block $~lib/staticarray/StaticArray + block $assembly/memory/ChunkBytes + block $assembly/memory/Result + block $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> + block $assembly/instructions/outcome/OutcomeData + block $"~lib/map/Map" + block $~lib/array/Array + block $assembly/memory-page/Arena + block $assembly/memory/Memory + block $~lib/staticarray/StaticArray + block $assembly/memory-page/RawPage + block $assembly/memory-page/Page + block $assembly/memory/MaybePageFault + block $~lib/array/Array + block $assembly/arguments/Nibbles + block $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> + block $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> + block $assembly/arguments/Args + block $~lib/typedarray/Uint8Array + block $~lib/array/Array + block $~lib/arraybuffer/ArrayBufferView + block $~lib/string/String + block $~lib/arraybuffer/ArrayBuffer + block $~lib/object/Object + local.get $0 + i32.const 8 + i32.sub + i32.load + br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $~lib/arraybuffer/ArrayBufferView $~lib/array/Array $~lib/typedarray/Uint8Array $assembly/arguments/Args $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $assembly/arguments/Nibbles $~lib/array/Array $assembly/memory/MaybePageFault $assembly/memory-page/Page $assembly/memory-page/RawPage $~lib/staticarray/StaticArray $assembly/memory/Memory $assembly/memory-page/Arena $~lib/array/Array $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $assembly/memory/Result $assembly/memory/ChunkBytes $~lib/staticarray/StaticArray $assembly/memory/Chunks $assembly/memory/PageData $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $~lib/array/Array $~lib/function/Function<%28u8%29=>u8> $assembly/interpreter/Interpreter $assembly/program/Program $assembly/program/Mask $~lib/staticarray/StaticArray $assembly/program/JumpTable $assembly/program/BasicBlocks $~lib/staticarray/StaticArray $assembly/gas/GasCounter $assembly/program/CodeAndMetadata $assembly/codec/Decoder $~lib/staticarray/StaticArray<~lib/string/String> $assembly/codec/ValOffset $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> $~lib/array/Array $~lib/array/Array $assembly/api-generic/VmOutput $assembly/api-generic/InitialChunk $~lib/array/Array $assembly/api-generic/VmInput $assembly/api-generic/InitialPage $~lib/array/Array $assembly/memory/MemoryBuilder $assembly/gas/GasCounterU64 $~lib/array/Array<~lib/string/String> $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> $assembly/program/ResolvedArguments $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $~lib/array/Array $~lib/staticarray/StaticArray $~lib/dataview/DataView $invalid + end + return + end + return + end + return + end + local.get $0 + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/typedarray/Uint8Array~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/Page~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/RawPage~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory/Memory~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/Arena~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $"~lib/map/Map~visit" + return + end + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/Result~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/ChunkBytes~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory/Chunks~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/PageData~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28u8%29=>u8>~visit + return + end + local.get $0 + local.get $1 + call $assembly/interpreter/Interpreter~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/Program~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/Mask~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/program/JumpTable~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/BasicBlocks~visit + return + end + return + end + return + end + local.get $0 + local.get $1 + call $assembly/program/CodeAndMetadata~visit + return + end + local.get $0 + local.get $1 + call $assembly/codec/Decoder~visit + return + end + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray<~lib/string/String>~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/api-generic/VmOutput~visit + return + end + local.get $0 + local.get $1 + call $assembly/api-generic/InitialChunk~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/api-generic/VmInput~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/MemoryBuilder~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<~lib/string/String>~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/ResolvedArguments~visit + return + end + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/dataview/DataView~visit + return + end + unreachable + ) + (func $~setArgumentsLength (param $0 i32) + local.get $0 + global.set $~argumentsLength + ) + (func $~start + call $start:assembly/index + ) + (func $~stack_check + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__data_end + i32.lt_s + if + i32.const 53072 + i32.const 53120 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + ) + (func $assembly/arguments/Args#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 6 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:b + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:c + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:d + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/arguments/Args.from (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32) + (local $x i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $x + i32.store + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $a + call $assembly/arguments/Args#set:a + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $b + call $assembly/arguments/Args#set:b + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $c + call $assembly/arguments/Args#set:c + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $d + call $assembly/arguments/Args#set:d + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/typedarray/Uint8Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/typedarray/Uint8Array#subarray (param $this i32) (param $begin i32) (param $end i32) (result i32) + (local $array i32) + (local $begin|4 i32) + (local $end|5 i32) + (local $len i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + (local $out i32) + (local $buf i32) + (local $19 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + block $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $array + i32.store + local.get $begin + local.set $begin|4 + local.get $end + local.set $end|5 + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + local.get $begin|4 + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $begin|4 + i32.add + local.tee $7 + i32.const 0 + local.tee $8 + local.get $7 + local.get $8 + i32.gt_s + select + else + local.get $begin|4 + local.tee $9 + local.get $len + local.tee $10 + local.get $9 + local.get $10 + i32.lt_s + select + end + local.set $begin|4 + local.get $end|5 + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $end|5 + i32.add + local.tee $11 + i32.const 0 + local.tee $12 + local.get $11 + local.get $12 + i32.gt_s + select + else + local.get $end|5 + local.tee $13 + local.get $len + local.tee $14 + local.get $13 + local.get $14 + i32.lt_s + select + end + local.set $end|5 + local.get $end|5 + local.tee $15 + local.get $begin|4 + local.tee $16 + local.get $15 + local.get $16 + i32.gt_s + select + local.set $end|5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=8 + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $buf + local.get $out + local.get $buf + i32.store + local.get $out + local.get $buf + i32.const 0 + call $~lib/rt/itcms/__link + local.get $out + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $begin|4 + i32.const 0 + i32.shl + i32.add + i32.store offset=4 + local.get $out + local.get $end|5 + local.get $begin|4 + i32.sub + i32.const 0 + i32.shl + i32.store offset=8 + local.get $out + br $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" + end + local.set $19 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $19 + return + ) + (func $~lib/typedarray/Uint8Array#__get (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + i32.ge_u + if + i32.const 480 + i32.const 720 + i32.const 167 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $index + i32.add + i32.load8_u + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/arguments/decodeI32 (param $input i32) (param $start i32) (param $end i32) (result i32) + (local $data i32) + (local $value1 f64) + (local $value2 f64) + (local $len i32) + (local $num i32) + (local $i i32) + (local $msb i32) + (local $prefix i32) + (local $i|11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $input + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $start + local.get $end + local.get $start + i32.gt_u + if (result i32) + local.get $end + else + local.get $start + end + call $~lib/typedarray/Uint8Array#subarray + local.tee $data + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.0 (result f64) + f64.const 4 + local.set $value1 + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.0 + end + i32.trunc_sat_f64_u + local.set $len + i32.const 0 + local.set $num + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_u + if + local.get $num + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.get $i + i32.const 8 + i32.mul + i32.shl + i32.or + local.set $num + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $len + i32.const 0 + i32.gt_u + if (result i32) + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $len + i32.const 1 + i32.sub + call $~lib/typedarray/Uint8Array#__get + i32.const 128 + i32.and + else + i32.const 0 + end + local.set $msb + local.get $msb + i32.const 0 + i32.gt_u + if (result i32) + i32.const 255 + else + i32.const 0 + end + local.set $prefix + local.get $len + local.set $i|11 + loop $for-loop|1 + local.get $i|11 + i32.const 4 + i32.lt_u + if + local.get $num + local.get $prefix + local.get $i|11 + i32.const 8 + i32.mul + i32.shl + i32.or + local.set $num + local.get $i|11 + i32.const 1 + i32.add + local.set $i|11 + br $for-loop|1 + end + end + local.get $num + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $start:assembly/arguments~anonymous|1 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/arguments/Nibbles#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 2 + i32.const 9 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Nibbles#set:low + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Nibbles#set:hig + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/arguments/nibbles (param $byte i32) (result i32) + (local $low i32) + (local $hig i32) + (local $n i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $byte + i32.const 15 + i32.and + local.set $low + local.get $byte + i32.const 255 + i32.and + i32.const 4 + i32.const 7 + i32.and + i32.shr_u + local.set $hig + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Nibbles#constructor + local.tee $n + i32.store + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $low + call $assembly/arguments/Nibbles#set:low + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $hig + call $assembly/arguments/Nibbles#set:hig + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/arguments/twoImm (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $first i32) + (local $second i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.1 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.1 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $first + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $second + local.get $first + local.get $second + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|2 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $lim + call $assembly/arguments/twoImm + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $start:assembly/arguments~anonymous|3 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/arguments~anonymous|4 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/typedarray/Uint8Array#subarray@varargs (param $this i32) (param $begin i32) (param $end i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $begin + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $begin + local.get $end + call $~lib/typedarray/Uint8Array#subarray + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/arguments/decodeU32 (param $data i32) (result i32) + (local $num i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 2 + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 3 + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + local.set $num + local.get $num + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/arguments~anonymous|5 (param $data i32) (param $_lim i32) (result i32) + (local $a i32) + (local $b i32) + (local $c i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Nibbles#get:low + local.set $a + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/decodeU32 + local.set $b + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 5 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/decodeU32 + local.set $c + local.get $a + i32.const 255 + i32.and + local.get $b + local.get $c + i32.const 0 + call $assembly/arguments/Args.from + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/arguments~anonymous|6 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $immA i32) + (local $immB i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.2 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.2 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $immA + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $immB + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $immA + local.get $immB + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|7 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $immA i32) + (local $offs i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.3 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.3 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $immA + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $offs + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $immA + local.get $offs + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|8 (param $data i32) (param $_lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|9 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|10 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|11 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + i32.const 1 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $lim + i32.const 1 + i32.gt_u + if (result i32) + local.get $lim + i32.const 1 + i32.sub + else + i32.const 0 + end + call $assembly/arguments/twoImm + local.tee $result + i32.store offset=12 + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:a + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/arguments/Args.from + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/arguments~anonymous|12 (param $data i32) (param $_lim i32) (result i32) + (local $a i32) + (local $b i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $a + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $b + i32.store offset=8 + local.get $a + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $a + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $b + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + i32.const 0 + call $assembly/arguments/Args.from + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/array/ensureCapacity (param $array i32) (param $newSize i32) (param $alignLog2 i32) (param $canGrow i32) + (local $oldCapacity i32) + (local $oldData i32) + (local $6 i32) + (local $7 i32) + (local $newCapacity i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $newData i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $array + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + local.set $oldCapacity + local.get $newSize + local.get $oldCapacity + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + local.get $newSize + i32.const 1073741820 + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8128 + i32.const 19 + i32.const 48 + call $~lib/builtins/abort + unreachable + end + local.get $array + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $oldData + local.get $newSize + local.tee $6 + i32.const 8 + local.tee $7 + local.get $6 + local.get $7 + i32.gt_u + select + local.get $alignLog2 + i32.shl + local.set $newCapacity + local.get $canGrow + if + local.get $oldCapacity + i32.const 1 + i32.shl + local.tee $9 + i32.const 1073741820 + local.tee $10 + local.get $9 + local.get $10 + i32.lt_u + select + local.tee $11 + local.get $newCapacity + local.tee $12 + local.get $11 + local.get $12 + i32.gt_u + select + local.set $newCapacity + end + local.get $oldData + local.get $newCapacity + call $~lib/rt/itcms/__renew + local.set $newData + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $newData + local.get $oldData + i32.ne + if + local.get $array + local.get $newData + i32.store + local.get $array + local.get $newData + i32.store offset=4 + local.get $array + local.get $newData + i32.const 0 + call $~lib/rt/itcms/__link + end + local.get $array + local.get $newCapacity + i32.store offset=8 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 1296 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/MISSING_INSTRUCTION + i32.const 1344 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/SBRK + global.get $~lib/memory/__stack_pointer + i32.const 231 + i32.const 2 + i32.const 10 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.const 1376 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 1408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 5 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 6 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 7 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 8 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 9 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 10 + i32.const 1456 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 11 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 12 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 13 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 14 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 15 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 16 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 17 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 18 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 19 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 20 + i32.const 1488 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneExtImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 21 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 22 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 23 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 24 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 25 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 26 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 27 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 28 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 29 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 30 + i32.const 1536 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 31 + i32.const 1584 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 32 + i32.const 1632 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 33 + i32.const 1680 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 34 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 35 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 36 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 37 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 38 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 39 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 40 + i32.const 1728 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 41 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 42 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 43 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 44 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 45 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 46 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 47 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 48 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 49 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 50 + i32.const 1760 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 51 + i32.const 1808 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 52 + i32.const 1856 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 53 + i32.const 1904 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 54 + i32.const 1952 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 55 + i32.const 2000 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 56 + i32.const 2048 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 57 + i32.const 2096 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 58 + i32.const 2144 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 59 + i32.const 2192 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 60 + i32.const 2240 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 61 + i32.const 2288 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 62 + i32.const 2336 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 63 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 64 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 65 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 66 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 67 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 68 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 69 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 70 + i32.const 2384 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 71 + i32.const 2448 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 72 + i32.const 2512 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 73 + i32.const 2576 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 74 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 75 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 76 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 77 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 78 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 79 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 80 + i32.const 2640 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 81 + i32.const 2688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 82 + i32.const 2736 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 83 + i32.const 2784 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 84 + i32.const 2848 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 85 + i32.const 2912 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 86 + i32.const 2976 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 87 + i32.const 3040 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 88 + i32.const 3104 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 89 + i32.const 3168 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 90 + i32.const 3232 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 91 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 92 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 93 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 94 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 95 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 96 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 97 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 98 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 99 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 100 + i32.const 3296 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 101 + global.get $assembly/instructions/SBRK + call $~lib/array/Array#__set + local.get $0 + i32.const 102 + i32.const 3344 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 103 + i32.const 3408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 104 + i32.const 3472 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 105 + i32.const 3536 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 106 + i32.const 3600 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 107 + i32.const 3664 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 108 + i32.const 3728 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 109 + i32.const 3776 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 110 + i32.const 3824 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 111 + i32.const 3872 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 112 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 113 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 114 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 115 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 116 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 117 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 118 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 119 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 120 + i32.const 3920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 121 + i32.const 3968 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 122 + i32.const 4016 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 123 + i32.const 4064 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 124 + i32.const 4112 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 125 + i32.const 4160 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 126 + i32.const 4208 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 127 + i32.const 4256 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 128 + i32.const 4304 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 129 + i32.const 4352 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 130 + i32.const 4400 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 131 + i32.const 4448 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 132 + i32.const 4496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 133 + i32.const 4544 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 134 + i32.const 4592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 135 + i32.const 4624 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 136 + i32.const 4672 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 137 + i32.const 4720 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 138 + i32.const 4768 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 139 + i32.const 4816 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 140 + i32.const 4864 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 141 + i32.const 4912 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 142 + i32.const 4960 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 143 + i32.const 5008 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 144 + i32.const 5056 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 145 + i32.const 5120 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 146 + i32.const 5184 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 147 + i32.const 5248 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 148 + i32.const 5296 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 149 + i32.const 5344 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 150 + i32.const 5392 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 151 + i32.const 5440 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 152 + i32.const 5488 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 153 + i32.const 5536 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 154 + i32.const 5584 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 155 + i32.const 5632 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 156 + i32.const 5696 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 157 + i32.const 5760 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 158 + i32.const 5824 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 159 + i32.const 5872 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 160 + i32.const 5936 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 161 + i32.const 5984 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 162 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 163 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 164 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 165 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 166 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 167 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 168 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 169 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 170 + i32.const 6048 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 171 + i32.const 6096 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 172 + i32.const 6144 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 173 + i32.const 6192 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 174 + i32.const 6240 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 175 + i32.const 6288 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 176 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 177 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 178 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 179 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 180 + i32.const 6336 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegTwoImm + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 181 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 182 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 183 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 184 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 185 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 186 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 187 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 188 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 189 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 190 + i32.const 6400 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 191 + i32.const 6432 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 192 + i32.const 6464 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 193 + i32.const 6496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 194 + i32.const 6544 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 195 + i32.const 6592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 196 + i32.const 6640 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 197 + i32.const 6688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 198 + i32.const 6736 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 199 + i32.const 6784 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 200 + i32.const 6832 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 201 + i32.const 6864 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 202 + i32.const 6896 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 203 + i32.const 6928 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 204 + i32.const 6976 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 205 + i32.const 7024 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 206 + i32.const 7072 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 207 + i32.const 7120 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 208 + i32.const 7168 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 209 + i32.const 7216 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 210 + i32.const 7264 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 211 + i32.const 7296 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 212 + i32.const 7328 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 213 + i32.const 7360 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 214 + i32.const 7408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 215 + i32.const 7456 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 216 + i32.const 7504 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 217 + i32.const 7552 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 218 + i32.const 7600 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 219 + i32.const 7648 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 220 + i32.const 7696 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 221 + i32.const 7744 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 222 + i32.const 7792 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 223 + i32.const 7840 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 224 + i32.const 7888 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 225 + i32.const 7936 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 226 + i32.const 7968 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 227 + i32.const 8000 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 228 + i32.const 8032 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 229 + i32.const 8064 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 230 + i32.const 8096 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/INSTRUCTIONS + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/MaybePageFault#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 11 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:isFault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:isAccess + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:fault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/arraybuffer/ArrayBufferView#constructor (param $this i32) (param $length i32) (param $alignLog2 i32) (result i32) + (local $buffer i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 3 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:buffer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:byteLength + local.get $length + i32.const 1073741820 + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8224 + i32.const 19 + i32.const 57 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $length + local.get $alignLog2 + i32.shl + local.tee $length + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $buffer + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $~lib/arraybuffer/ArrayBufferView#set:buffer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $buffer + call $~lib/arraybuffer/ArrayBufferView#set:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $length + call $~lib/arraybuffer/ArrayBufferView#set:byteLength + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $length + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#constructor + local.tee $this + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/memory-page/Page#constructor (param $this i32) (param $access i32) (param $raw i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 12 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $access + call $assembly/memory-page/Page#set:access + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $raw + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory-page/Page#set:raw + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory-page/RawPage#constructor (param $this i32) (param $id i32) (param $page i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 13 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $id + call $assembly/memory-page/RawPage#set:id + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $page + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory-page/RawPage#set:page + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $start:assembly/memory + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + call $start:assembly/memory-page + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + global.set $assembly/memory/NO_PAGE_FAULT + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + global.set $assembly/memory/EMPTY_UINT8ARRAY + i32.const 0 + global.get $assembly/memory-page/Access.None + i32.const 0 + i32.const -1 + i32.const 0 + call $assembly/memory-page/RawPage#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/memory-page/Page#constructor + global.set $assembly/memory/EMPTY_PAGE + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i64) + (local $value i64) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/OutcomeData#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.const 19 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/instructions/outcome/Outcome.Ok + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:staticJump + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:dJump + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/instructions/outcome/Result.PANIC + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:exitCode + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/bit~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.popcnt + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.popcnt + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.clz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.clz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ctz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.ctz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u8SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u16SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|8 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.const 65535 + i32.and + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|9 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/polyfills/bswap + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/instructions/outcome/staticJump (param $offset i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.StaticJump + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $offset + call $assembly/instructions/outcome/OutcomeData#set:staticJump + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/branch~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.eq + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.ne + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.lt_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.le_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.ge_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.gt_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.lt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.le_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.ge_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.gt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.eq + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ne + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_u + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ge_u + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ge_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/jump~anonymous|0 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:a + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/instructions/outcome/dJump (param $address i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.DynamicJump + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $address + call $assembly/instructions/outcome/OutcomeData#set:dJump + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/jump~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $address i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + local.get $address + call $assembly/instructions/outcome/dJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/jump~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/jump~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $address i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:d + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + local.get $address + call $assembly/instructions/outcome/dJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.const 32 + i64.shl + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/load~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory/Chunks#constructor (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 24 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:fault + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:first + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:second + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory/Chunks#constructor@varargs (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $first + i32.store + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $second + i32.store offset=4 + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + local.get $first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + local.get $second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + local.get $4 + call $assembly/memory/Chunks#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $"~lib/map/Map#find" (param $this i32) (param $key i32) (param $hashCode i32) (result i32) + (local $entry i32) + (local $taggedNext i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + i32.load + local.set $entry + loop $while-continue|0 + local.get $entry + if + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + local.set $taggedNext + local.get $taggedNext + i32.const 1 + i32.and + i32.eqz + if (result i32) + local.get $entry + call $"~lib/map/MapEntry#get:key" + local.get $key + i32.eq + else + i32.const 0 + end + if + local.get $entry + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $taggedNext + i32.const 1 + i32.const -1 + i32.xor + i32.and + local.set $entry + br $while-continue|0 + end + end + i32.const 0 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $"~lib/map/Map#has" (param $this i32) (param $key i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $key + local.get $key + call $~lib/util/hash/HASH + call $"~lib/map/Map#find" + i32.const 0 + i32.ne + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/PageData#constructor (param $this i32) (param $fault i32) (param $page i32) (param $relativeAddress i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 25 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/PageData#set:fault + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $page + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/PageData#set:page + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $relativeAddress + call $assembly/memory/PageData#set:relativeAddress + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory/fault (param $address i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isFault + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $address + call $assembly/memory/MaybePageFault#set:fault + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $"~lib/map/Map#get" (param $this i32) (param $key i32) (result i32) + (local $entry i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $key + local.get $key + call $~lib/util/hash/HASH + call $"~lib/map/Map#find" + local.set $entry + local.get $entry + i32.eqz + if + i32.const 9376 + i32.const 9440 + i32.const 105 + i32.const 17 + call $~lib/builtins/abort + unreachable + end + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory-page/Page#can (param $this i32) (param $access i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/Page#get:access + global.get $assembly/memory-page/Access.Write + i32.eq + if (result i32) + i32.const 1 + else + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/Page#get:access + local.get $access + i32.eq + end + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/Memory#getPage (param $this i32) (param $access i32) (param $address i32) (result i32) + (local $pageIdx i32) + (local $relAddress i32) + (local $pageStart i32) + (local $page i32) + (local $f i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $address + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $pageIdx + local.get $address + global.get $assembly/memory-page/PAGE_SIZE + i32.rem_u + local.set $relAddress + local.get $pageIdx + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + local.set $pageStart + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/memory/Memory#get:pages + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $pageIdx + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.get $pageStart + call $assembly/memory/fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory/EMPTY_PAGE + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/memory/Memory#get:pages + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $pageIdx + call $"~lib/map/Map#get" + local.tee $page + i32.store offset=8 + local.get $page + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $access + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $pageStart + call $assembly/memory/fault + local.tee $f + i32.store offset=12 + local.get $f + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isAccess + i32.const 0 + local.get $f + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory/EMPTY_PAGE + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $page + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/typedarray/Uint8Array#fill (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $value + local.get $start + local.get $end + call $~lib/util/bytes/FILL + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/typedarray/Uint8Array#fill@varargs (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $start + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $value + local.get $start + local.get $end + call $~lib/typedarray/Uint8Array#fill + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory-page/RawPage#get:data (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:page + i32.const 0 + i32.eq + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory-page/RawPage#set:page + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:page + local.tee $1 + i32.store offset=12 + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 9616 + i32.const 42 + i32.const 12 + call $~lib/builtins/abort + unreachable + end + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/Memory#getChunks (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) + (local $pageData i32) + (local $page i32) + (local $relativeAddress i32) + (local $endAddress i32) + (local $needSecondPage i32) + (local $first i32) + (local $secondPageIdx i32) + (local $secondPageStart i32) + (local $secondPage i32) + (local $f i32) + (local $firstChunk i32) + (local $secondChunk i32) + (local $16 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + local.get $bytes + i32.const 255 + i32.and + i32.const 0 + i32.eq + if + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $access + local.get $address + call $assembly/memory/Memory#getPage + local.tee $pageData + i32.store offset=4 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/PageData#get:fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/MaybePageFault#get:isFault + if + i32.const 0 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/PageData#get:fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/PageData#get:page + local.tee $page + i32.store offset=12 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/PageData#get:relativeAddress + local.set $relativeAddress + local.get $relativeAddress + local.get $bytes + i32.const 255 + i32.and + i32.add + local.set $endAddress + local.get $endAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.gt_u + local.set $needSecondPage + local.get $needSecondPage + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $page + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $relativeAddress + local.get $endAddress + call $~lib/typedarray/Uint8Array#subarray + local.tee $first + i32.store offset=20 + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $first + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + i32.const 2 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + local.get $address + local.get $bytes + i32.const 255 + i32.and + i32.add + i64.extend_i32_u + global.get $assembly/memory/MEMORY_SIZE + i64.rem_s + i32.wrap_i64 + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $secondPageIdx + local.get $secondPageIdx + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + local.set $secondPageStart + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/Memory#get:pages + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $secondPageIdx + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.get $secondPageStart + call $assembly/memory/fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/Memory#get:pages + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $secondPageIdx + call $"~lib/map/Map#get" + local.tee $secondPage + i32.store offset=24 + local.get $secondPage + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $access + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $secondPageStart + call $assembly/memory/fault + local.tee $f + i32.store offset=28 + local.get $f + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isAccess + i32.const 0 + local.get $f + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $page + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $relativeAddress + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $firstChunk + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $secondPage + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + local.get $relativeAddress + local.get $bytes + i32.const 255 + i32.and + i32.add + global.get $assembly/memory-page/PAGE_SIZE + i32.sub + call $~lib/typedarray/Uint8Array#subarray + local.tee $secondChunk + i32.store offset=36 + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $firstChunk + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + local.get $secondChunk + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory/Chunks#constructor + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + ) + (func $assembly/memory/ChunkBytes#constructor (param $this i32) (param $fault i32) (param $bytes i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 22 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $fault + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory/ChunkBytes#set:fault + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $bytes + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory/ChunkBytes#set:bytes + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory/ChunkBytes#constructor@varargs (param $this i32) (param $fault i32) (param $bytes i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/staticarray/StaticArray#constructor + local.tee $bytes + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $fault + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $bytes + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/memory/ChunkBytes#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/getBytes (param $bytes i32) (param $first i32) (param $second i32) (result i32) + (local $res i32) + (local $len i32) + (local $i i32) + (local $i|6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $bytes + i32.const 255 + i32.and + call $~lib/staticarray/StaticArray#constructor + local.tee $res + i32.store + local.get $first + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $i + local.get $first + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|6 + loop $for-loop|1 + local.get $i|6 + local.get $second + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $len + local.get $i|6 + i32.add + local.get $second + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + local.get $i|6 + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $i|6 + i32.const 1 + i32.add + local.set $i|6 + br $for-loop|1 + end + end + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $assembly/memory/Memory#getBytes (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) + (local $res i32) + (local $data i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $access + local.get $address + local.get $bytes + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $assembly/memory/MaybePageFault#get:isFault + if + i32.const 0 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/ChunkBytes#constructor@varargs + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + global.get $~lib/memory/__stack_pointer + local.get $bytes + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:first + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:second + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/getBytes + local.tee $data + i32.store offset=16 + i32.const 0 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/ChunkBytes#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/memory/Result#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 21 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/memory/Result#set:ok + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/Result#set:fault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory/Memory#getU8 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/instructions/outcome/okOrFault (param $pageFault i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MaybePageFault#get:isAccess + if (result i32) + global.get $assembly/instructions/outcome/Result.FAULT_ACCESS + else + global.get $assembly/instructions/outcome/Result.FAULT + end + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MaybePageFault#get:fault + call $assembly/instructions/outcome/OutcomeData#set:exitCode + end + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/load~anonymous|2 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getI8 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/u8SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|3 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU16 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getI16 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $l i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/Result#set:fault + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.const 15 + i32.and + i32.shl + i32.or + local.set $l + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $l + call $assembly/instructions/utils/u16SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU32 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getI32 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $l i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/Result#set:fault + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i32.or + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i32.or + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i32.or + local.set $l + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $l + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU64 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 8 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 8 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 16 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 24 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 4 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 32 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 5 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 40 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 6 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 48 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 7 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 56 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU64 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU64 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/logic~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.xor + i64.const -1 + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $c i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $c + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $c + i64.add + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.mul + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.const 4294967296 + i64.or + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i32.add + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 2 + i64.const 32 + call $~lib/math/ipow64 + i64.add + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + i64.sub + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.mul + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i32.div_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i32.MIN_VALUE + i64.extend_i32_s + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i32.rem_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i32) + (local $a i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i32.const -1 + i32.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i32.MIN_VALUE + i32.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + i64.extend_i32_s + local.get $a + i64.extend_i32_s + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.div_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i64.MIN_VALUE + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|18 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.rem_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|19 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i64.MIN_VALUE + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|20 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperSigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|21 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperUnsigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|22 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperSignedUnsigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|23 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.lt_s + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|24 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.lt_u + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|25 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.gt_s + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|26 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.gt_u + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/mov~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_l + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_l_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/set~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.lt_u + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.lt_s + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.gt_u + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.gt_s + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_u + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/set~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_s + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/shift~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $imm i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $imm + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $imm + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $regValue i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $regValue + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regValue + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/typedarray/Uint8Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + i32.ge_u + if + i32.const 480 + i32.const 720 + i32.const 178 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $index + i32.add + local.get $value + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU8 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 1 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|0 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU16 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 2 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.gt_s + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $value + i32.const 65535 + i32.and + i32.const 8 + i32.const 15 + i32.and + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + else + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 65535 + i32.and + i32.const 8 + i32.const 15 + i32.and + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|1 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU32 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $v i32) + (local $len i32) + (local $i i32) + (local $i|7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 4 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $value + local.set $v + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + local.get $v + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i32.const 8 + i32.shr_u + local.set $v + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i|7 + local.get $v + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i32.const 8 + i32.shr_u + local.set $v + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/instructions/store~anonymous|2 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#setU32 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU64 (param $this i32) (param $address i32) (param $value i64) (result i32) + (local $res i32) + (local $v i64) + (local $len i32) + (local $i i32) + (local $i|7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 8 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $value + local.set $v + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + local.get $v + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i64.const 8 + i64.shr_u + local.set $v + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i|7 + local.get $v + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i64.const 8 + i64.shr_u + local.set $v + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/instructions/store~anonymous|3 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Memory#setU64 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/memory/Memory#setU32 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Memory#setU64 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/instructions/outcome/status (param $result i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $result + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Result.HOST + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $id + call $assembly/instructions/outcome/OutcomeData#set:exitCode + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:a + call $assembly/instructions/outcome/hostCall + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#pop (param $this i32) (result i32) + (local $len i32) + (local $val i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + local.set $len + local.get $len + i32.const 1 + i32.lt_s + if + i32.const 13120 + i32.const 8128 + i32.const 271 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $len + i32.const 1 + i32.sub + local.tee $len + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $val + i32.store offset=4 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $len + call $~lib/array/Array#set:length_ + local.get $val + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/console/console.log (param $message i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $message + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/bindings/dom/console.log + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory-page/Arena#acquire (param $this i32) (result i32) + (local $allocatedMemory i32) + (local $data i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:free + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + i32.const 0 + i32.gt_s + if + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:free + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#pop + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.set $allocatedMemory + local.get $allocatedMemory + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/Arena#get:arenaBytes + i32.eq + if + i32.const 13168 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/console/console.log + end + global.get $~lib/memory/__stack_pointer + local.get $allocatedMemory + global.get $assembly/memory-page/ALLOCATE_EAGERLY + i32.lt_u + if (result i32) + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + else + i32.const 0 + end + local.tee $data + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + i32.const 1 + i32.add + call $assembly/memory-page/Arena#set:extraPageIndex + i32.const 0 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/RawPage#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) + (local $newBucketsCapacity i32) + (local $newBuckets i32) + (local $newEntriesCapacity i32) + (local $newEntries i32) + (local $oldPtr i32) + (local $oldEnd i32) + (local $newPtr i32) + (local $oldEntry i32) + (local $newEntry i32) + (local $oldEntryKey i32) + (local $newBucketIndex i32) + (local $newBucketPtrBase i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $newBucketsMask + i32.const 1 + i32.add + local.set $newBucketsCapacity + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $newBucketsCapacity + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newBuckets + i32.store + local.get $newBucketsCapacity + i32.const 8 + i32.mul + i32.const 3 + i32.div_s + local.set $newEntriesCapacity + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $newEntriesCapacity + block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.0" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newEntries + i32.store offset=4 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entries" + local.set $oldPtr + local.get $oldPtr + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.1" + end + i32.mul + i32.add + local.set $oldEnd + local.get $newEntries + local.set $newPtr + loop $while-continue|0 + local.get $oldPtr + local.get $oldEnd + i32.ne + if + local.get $oldPtr + local.set $oldEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $newPtr + local.set $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:key" + local.set $oldEntryKey + local.get $newEntry + local.get $oldEntryKey + call $"~lib/map/MapEntry#set:key" + local.get $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:value" + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/MapEntry#set:value" + local.get $oldEntryKey + call $~lib/util/hash/HASH + local.get $newBucketsMask + i32.and + local.set $newBucketIndex + local.get $newBuckets + local.get $newBucketIndex + i32.const 4 + i32.mul + i32.add + local.set $newBucketPtrBase + local.get $newEntry + local.get $newBucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $newBucketPtrBase + local.get $newPtr + i32.store + local.get $newPtr + block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.2" + end + i32.add + local.set $newPtr + end + local.get $oldPtr + block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.3" + end + i32.add + local.set $oldPtr + br $while-continue|0 + end + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBuckets + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBucketsMask + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntries + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntriesCapacity + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#get:entriesCount" + call $"~lib/map/Map#set:entriesOffset" + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) + (local $hashCode i32) + (local $entry i32) + (local $entries i32) + (local $6 i32) + (local $bucketPtrBase i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $key + call $~lib/util/hash/HASH + local.set $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $key + local.get $hashCode + call $"~lib/map/Map#find" + local.set $entry + local.get $entry + if + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.eq + if + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.const 3 + i32.mul + i32.const 4 + i32.div_s + i32.lt_s + if (result i32) + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.const 1 + i32.shl + i32.const 1 + i32.or + end + call $"~lib/map/Map#rehash" + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.tee $entries + i32.store offset=8 + local.get $entries + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.tee $6 + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesOffset" + local.get $6 + block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.4" + end + i32.mul + i32.add + local.set $entry + local.get $entry + local.get $key + call $"~lib/map/MapEntry#set:key" + i32.const 0 + drop + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + local.set $bucketPtrBase + local.get $entry + local.get $bucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $bucketPtrBase + local.get $entry + i32.store + end + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) + (local $freeMemoryStart i32) + (local $newSbrk i64) + (local $pageIdx i32) + (local $i i32) + (local $page i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $freeMemoryStart + i32.store + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $amount + i32.const 0 + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + local.get $amount + i64.extend_i32_u + i64.add + local.set $newSbrk + local.get $newSbrk + global.get $assembly/memory/MEMORY_SIZE + i64.ge_s + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Result#get:fault + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isFault + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $newSbrk + i32.wrap_i64 + call $assembly/memory/Memory#set:sbrkAddress + local.get $newSbrk + i64.const 1 + i64.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i64.extend_i32_s + i64.shr_s + i32.wrap_i64 + local.set $pageIdx + local.get $pageIdx + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.const 1 + i32.add + local.set $i + loop $for-loop|0 + local.get $i + local.get $pageIdx + i32.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:arena + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=12 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory/Memory#get:pages + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $i + i32.const 0 + global.get $assembly/memory-page/Access.Write + local.get $page + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory-page/Page#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $"~lib/map/Map#set" + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $pageIdx + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#sbrk + local.tee $res + i32.store offset=12 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/codec~anonymous|0 (param $firstByte i32) (result i32) + (local $len i32) + (local $i i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $assembly/codec/MASKS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.const 255 + i32.and + i32.lt_u + if + local.get $firstByte + i32.const 255 + i32.and + global.get $assembly/codec/MASKS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $i + call $~lib/array/Array#__get + i32.ge_u + if + i32.const 8 + local.get $i + i32.sub + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/array/Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/array/Array#get:dataStart + local.set $sourceStart + i32.const 0 + i32.eqz + drop + local.get $targetStart + local.get $sourceStart + local.get $sourceLen + i32.const 0 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/liftBytes (param $data i32) (result i32) + (local $p i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $p + i32.store offset=4 + local.get $p + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#set<~lib/array/Array> + local.get $p + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#constructor (param $this i32) (param $source i32) (param $offset i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 38 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $source + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/codec/Decoder#set:source + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $offset + call $assembly/codec/Decoder#set:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/util/string/joinStringArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $4 i32) + (local $estLen i32) + (local $value i32) + (local $i i32) + (local $offset i32) + (local $sepLen i32) + (local $result i32) + (local $i|11 i32) + (local $valueLen i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 14400 + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + end + local.get $lastIndex + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + i32.load + local.tee $4 + i32.store + local.get $4 + if (result i32) + local.get $4 + else + i32.const 14400 + end + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + end + i32.const 0 + local.set $estLen + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $i + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $estLen + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + i32.add + local.set $estLen + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $offset + local.get $separator + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + local.set $sepLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + local.get $sepLen + local.get $lastIndex + i32.mul + i32.add + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=12 + i32.const 0 + local.set $i|11 + loop $for-loop|1 + local.get $i|11 + local.get $lastIndex + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $i|11 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + local.set $valueLen + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value + local.get $valueLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $valueLen + i32.add + local.set $offset + end + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i|11 + i32.const 1 + i32.add + local.set $i|11 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $lastIndex + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + memory.copy + end + local.get $result + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + i32.const 1 + i32.lt_s + drop + i32.const 1 + drop + local.get $this + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/staticarray/StaticArray<~lib/string/String>#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/util/string/joinStringArray + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#ensureBytes (param $this i32) (param $need i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#get:offset + local.get $need + i32.add + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/codec/Decoder#get:source + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $need + i32.const 10 + call $~lib/number/U32#toString + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/codec/Decoder#get:source + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#get:offset + i32.sub + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=12 + i32.const 14560 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $2 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 14560 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 3 + local.get $3 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 14560 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 14400 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 16384 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/ValOffset#constructor (param $this i32) (param $value i32) (param $offset i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 40 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $value + call $assembly/codec/ValOffset#set:value + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $offset + call $assembly/codec/ValOffset#set:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/codec/decodeVarU32 (param $data i32) (result i32) + (local $length i32) + (local $first i32) + (local $3 i32) + (local $4 i32) + (local $msb i32) + (local $number i32) + (local $i i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + i32.const 1 + global.set $~argumentsLength + global.get $assembly/codec/variableLength + i32.load + call_indirect (type $0) + i32.const 255 + i32.and + local.set $length + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $first + local.get $length + i32.const 0 + i32.eq + if + i32.const 0 + local.get $first + i32.const 1 + call $assembly/codec/ValOffset#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.get $length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.const 10 + call $~lib/number/I32#toString + local.tee $4 + i32.store offset=8 + i32.const 16608 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $3 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 16608 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 3 + local.get $4 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 16608 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 14400 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 16384 + i32.const 108 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $first + i32.const 2 + i32.const 8 + local.get $length + i32.sub + call $~lib/math/ipow32 + i32.add + i32.const 2 + i32.const 8 + call $~lib/math/ipow32 + i32.sub + local.get $length + i32.const 8 + i32.mul + i32.shl + local.set $msb + i32.const 0 + local.set $number + local.get $length + i32.const 1 + i32.sub + local.set $i + loop $for-loop|0 + local.get $i + i32.const 0 + i32.ge_s + if + local.get $number + i32.const 8 + i32.shl + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $i + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.add + local.set $number + local.get $i + i32.const 1 + i32.sub + local.set $i + br $for-loop|0 + end + end + local.get $number + local.get $msb + i32.add + local.set $number + i32.const 0 + local.get $number + i32.const 1 + local.get $length + i32.add + call $assembly/codec/ValOffset#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/codec/Decoder#varU32 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/codec/decodeVarU32 + local.tee $v + i32.store offset=12 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/ValOffset#get:offset + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/codec/ValOffset#get:value + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#bytes (param $this i32) (param $len i32) (result i32) + (local $v i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $len + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:source + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $len + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $v + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $len + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/codec/Decoder#remainingBytes (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $v + i32.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/typedarray/Uint8Array#get:length + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/program/CodeAndMetadata#constructor (param $this i32) (param $code i32) (param $metadata i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 37 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $code + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/program/CodeAndMetadata#set:code + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $metadata + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/program/CodeAndMetadata#set:metadata + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/program/extractCodeAndMetadata (param $data i32) (result i32) + (local $decoder i32) + (local $metadataLength i32) + (local $metadata i32) + (local $code i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/codec/Decoder#varU32 + local.set $metadataLength + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $metadataLength + call $assembly/codec/Decoder#bytes + local.tee $metadata + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/codec/Decoder#remainingBytes + local.tee $code + i32.store offset=12 + i32.const 0 + local.get $code + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $metadata + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/program/CodeAndMetadata#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/string/String#concat (param $this i32) (param $other i32) (result i32) + (local $thisSize i32) + (local $otherSize i32) + (local $outSize i32) + (local $out i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $thisSize + local.get $other + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $otherSize + local.get $thisSize + local.get $otherSize + i32.add + local.set $outSize + local.get $outSize + i32.const 0 + i32.eq + if + i32.const 14400 + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $out + local.get $this + local.get $thisSize + memory.copy + local.get $out + local.get $thisSize + i32.add + local.get $other + local.get $otherSize + memory.copy + local.get $out + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $~lib/string/String.__concat (param $left i32) (param $right i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $left + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $right + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/string/String#concat + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/string/String#padStart (param $this i32) (param $length i32) (param $pad i32) (result i32) + (local $thisSize i32) + (local $targetSize i32) + (local $padSize i32) + (local $prependSize i32) + (local $out i32) + (local $repeatCount i32) + (local $restBase i32) + (local $restSize i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $thisSize + local.get $length + i32.const 1 + i32.shl + local.set $targetSize + local.get $pad + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $padSize + local.get $targetSize + local.get $thisSize + i32.lt_u + if (result i32) + i32.const 1 + else + local.get $padSize + i32.eqz + end + if + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $targetSize + local.get $thisSize + i32.sub + local.set $prependSize + global.get $~lib/memory/__stack_pointer + local.get $targetSize + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $prependSize + local.get $padSize + i32.gt_u + if + local.get $prependSize + i32.const 2 + i32.sub + local.get $padSize + i32.div_u + local.set $repeatCount + local.get $repeatCount + local.get $padSize + i32.mul + local.set $restBase + local.get $prependSize + local.get $restBase + i32.sub + local.set $restSize + local.get $out + local.get $pad + local.get $padSize + local.get $repeatCount + call $~lib/memory/memory.repeat + local.get $out + local.get $restBase + i32.add + local.get $pad + local.get $restSize + memory.copy + else + local.get $out + local.get $pad + local.get $prependSize + memory.copy + end + local.get $out + local.get $prependSize + i32.add + local.get $this + local.get $thisSize + memory.copy + local.get $out + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $assembly/index/disassemble~anonymous|0 (param $acc i32) (param $x i32) (param $$2 i32) (param $$3 i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $acc + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $x + i32.const 16 + call $~lib/number/U8#toString + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + i32.const 2 + i32.const 14800 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $~lib/string/String#padStart + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/string/String.__concat + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#reduce<~lib/string/String> (param $this i32) (param $fn i32) (param $initialValue i32) (result i32) + (local $array i32) + (local $fn|4 i32) + (local $initialValue|5 i32) + (local $ptr i32) + (local $i i32) + (local $k i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + block $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" (result i32) + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $array + i32.store + global.get $~lib/memory/__stack_pointer + local.get $fn + local.tee $fn|4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $initialValue + local.tee $initialValue|5 + i32.store offset=8 + local.get $array + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.set $ptr + i32.const 0 + local.set $i + local.get $array + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.set $k + loop $for-loop|0 + local.get $i + local.get $k + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $initialValue|5 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + local.get $ptr + local.get $i + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.get $i + local.get $array + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 4 + global.set $~argumentsLength + local.get $fn|4 + i32.load + call_indirect (type $5) + local.tee $initialValue|5 + i32.store offset=8 + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $initialValue|5 + br $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" + end + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $assembly/codec/Decoder#u8 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/Mask#constructor (param $this i32) (param $packedMask i32) (param $codeLength i32) (result i32) + (local $lastInstructionOffset i32) + (local $i i32) + (local $bits i32) + (local $index i32) + (local $b i32) + (local $isSet i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 31 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + call $assembly/program/Mask#set:bytesToSkip + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + local.get $codeLength + call $~lib/staticarray/StaticArray#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/Mask#set:bytesToSkip + i32.const 0 + local.set $lastInstructionOffset + local.get $packedMask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.sub + local.set $i + loop $for-loop|0 + local.get $i + i32.const 0 + i32.ge_s + if + local.get $packedMask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $bits + local.get $i + i32.const 8 + i32.mul + local.set $index + i32.const 7 + local.set $b + loop $for-loop|2 + local.get $b + i32.const 0 + i32.ge_s + if + local.get $bits + i32.const 128 + i32.and + local.set $isSet + local.get $bits + i32.const 1 + i32.const 7 + i32.and + i32.shl + local.set $bits + local.get $index + local.get $b + i32.add + local.get $codeLength + i32.lt_s + if + local.get $isSet + if (result i32) + i32.const 0 + else + local.get $lastInstructionOffset + i32.const 1 + i32.add + end + local.set $lastInstructionOffset + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/Mask#get:bytesToSkip + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $index + local.get $b + i32.add + local.get $lastInstructionOffset + global.get $assembly/program/MAX_SKIP + i32.const 1 + i32.add + i32.lt_u + if (result i32) + local.get $lastInstructionOffset + else + global.get $assembly/program/MAX_SKIP + i32.const 1 + i32.add + end + call $~lib/staticarray/StaticArray#__set + end + local.get $b + i32.const 1 + i32.sub + local.set $b + br $for-loop|2 + end + end + local.get $i + i32.const 1 + i32.sub + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + ) + (func $assembly/program/JumpTable#constructor (param $this i32) (param $itemBytes i32) (param $data i32) (result i32) + (local $jumps i32) + (local $i i32) + (local $num i64) + (local $j i32) + (local $nextNum i64) + (local $isOverflow i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 33 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + call $assembly/program/JumpTable#set:jumps + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $itemBytes + i32.const 255 + i32.and + i32.const 0 + i32.gt_u + if (result i32) + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.get $itemBytes + i32.const 255 + i32.and + i32.div_s + else + i32.const 0 + end + call $~lib/staticarray/StaticArray#constructor + local.tee $jumps + i32.store offset=8 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + i64.const 0 + local.set $num + local.get $itemBytes + i32.const 1 + i32.sub + i32.const 255 + i32.and + local.set $j + loop $for-loop|1 + local.get $j + i32.const 0 + i32.ge_s + if + local.get $num + i64.const 8 + i64.shl + local.set $nextNum + local.get $nextNum + local.get $num + i64.lt_u + local.set $isOverflow + local.get $nextNum + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + local.get $j + i32.add + call $~lib/typedarray/Uint8Array#__get + i64.extend_i32_u + i64.add + local.set $nextNum + local.get $isOverflow + if (result i32) + i32.const 1 + else + local.get $nextNum + local.get $num + i64.lt_u + end + local.set $isOverflow + local.get $isOverflow + if (result i64) + global.get $~lib/builtins/u64.MAX_VALUE + else + local.get $nextNum + end + local.set $num + local.get $j + i32.const 1 + i32.sub + local.set $j + br $for-loop|1 + end + end + local.get $jumps + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + local.get $itemBytes + i32.const 255 + i32.and + i32.div_s + local.get $num + call $~lib/staticarray/StaticArray#__set + local.get $i + local.get $itemBytes + i32.const 255 + i32.and + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $jumps + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $assembly/program/JumpTable#set:jumps + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/Mask#isInstruction (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + i64.extend_i32_u + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i64.extend_i32_s + i64.ge_u + if + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $index + call $~lib/staticarray/StaticArray#__get + i32.const 0 + i32.eq + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/program/Mask#skipBytesToNextInstruction (param $this i32) (param $i i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $i + i32.const 1 + i32.add + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i32.lt_u + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $i + i32.const 1 + i32.add + call $~lib/staticarray/StaticArray#__get + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/BasicBlocks#constructor (param $this i32) (param $code i32) (param $mask i32) (result i32) + (local $len i32) + (local $isStartOrEnd i32) + (local $n i32) + (local $isInstructionInMask i32) + (local $skipArgs i32) + (local $iData i32) + (local $isTerminating i32) + (local $newBlockStart i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 34 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + call $assembly/program/BasicBlocks#set:isStartOrEnd + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $len + call $~lib/staticarray/StaticArray#constructor + local.tee $isStartOrEnd + i32.store offset=8 + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + i32.const 0 + local.set $n + loop $for-loop|0 + local.get $n + local.get $len + i32.lt_s + if + block $for-continue|0 + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $assembly/program/Mask#isInstruction + local.set $isInstructionInMask + local.get $isInstructionInMask + i32.eqz + if + br $for-continue|0 + end + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipArgs + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#__get + end + local.set $iData + local.get $iData + call $assembly/instructions/Instruction#get:isTerminating + local.set $isTerminating + local.get $isTerminating + if + local.get $n + i32.const 1 + i32.add + local.get $skipArgs + i32.add + local.set $newBlockStart + local.get $newBlockStart + local.get $len + i32.lt_s + if + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $newBlockStart + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + end + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + local.get $n + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.END + i32.or + call $~lib/staticarray/StaticArray#__set + end + end + local.get $n + i32.const 1 + i32.add + local.set $n + br $for-loop|0 + end + end + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + call $assembly/program/BasicBlocks#set:isStartOrEnd + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + ) + (func $assembly/program/Program#constructor (param $this i32) (param $code i32) (param $mask i32) (param $jumpTable i32) (param $basicBlocks i32) (result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 30 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $code + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:code + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:mask + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:jumpTable + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $basicBlocks + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:basicBlocks + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/program/deblob (param $program i32) (result i32) + (local $decoder i32) + (local $jumpTableLength i32) + (local $jumpTableItemLength i32) + (local $codeLength i32) + (local $jumpTableLengthInBytes i32) + (local $rawJumpTable i32) + (local $rawCode i32) + (local $rawMask i32) + (local $mask i32) + (local $jumpTable i32) + (local $basicBlocks i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $program + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#varU32 + local.set $jumpTableLength + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#u8 + local.set $jumpTableItemLength + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#varU32 + local.set $codeLength + local.get $jumpTableLength + local.get $jumpTableItemLength + i32.mul + local.set $jumpTableLengthInBytes + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $jumpTableLengthInBytes + call $assembly/codec/Decoder#bytes + local.tee $rawJumpTable + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + call $assembly/codec/Decoder#bytes + local.tee $rawCode + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + i32.const 7 + i32.add + i32.const 8 + i32.div_u + call $assembly/codec/Decoder#bytes + local.tee $rawMask + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $rawMask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $jumpTableItemLength + local.get $rawJumpTable + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/program/JumpTable#constructor + local.tee $jumpTable + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $rawCode + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $mask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=28 + local.get $12 + call $assembly/program/BasicBlocks#constructor + local.tee $basicBlocks + i32.store offset=32 + i32.const 0 + local.get $rawCode + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $mask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=28 + local.get $12 + local.get $jumpTable + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=36 + local.get $12 + local.get $basicBlocks + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=40 + local.get $12 + call $assembly/program/Program#constructor + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/decodeArguments (param $kind i32) (param $data i32) (param $lim i32) (result i32) + (local $extended i32) + (local $i i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + global.get $assembly/arguments/REQUIRED_BYTES + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $kind + call $~lib/array/Array#__get + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/arguments/REQUIRED_BYTES + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $kind + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#constructor + local.tee $extended + i32.store offset=4 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $extended + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $extended + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $lim + i32.const 2 + global.set $~argumentsLength + global.get $assembly/arguments/DECODERS + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $kind + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $3) + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $lim + i32.const 2 + global.set $~argumentsLength + global.get $assembly/arguments/DECODERS + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $kind + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $3) + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/api-generic/getAssembly (param $p i32) (result i32) + (local $len i32) + (local $v i32) + (local $i i32) + (local $instruction i32) + (local $iData i32) + (local $6 i32) + (local $skipBytes i32) + (local $args i32) + (local $9 i32) + (local $argsArray i32) + (local $relevantArgs i32) + (local $i|12 i32) + (local $13 i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + local.get $len + i32.const 0 + i32.eq + if + i32.const 16928 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 14400 + local.tee $v + i32.store offset=8 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + call $assembly/program/Mask#isInstruction + i32.eqz + if + i32.const 17008 + i32.const 17120 + i32.const 46 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $instruction + call $~lib/array/Array#__get + end + local.set $iData + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const 17200 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + i32.const 10 + call $~lib/number/I32#toString + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 17232 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/string/String#concat + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $iData + call $assembly/instructions/Instruction#get:namePtr + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $~lib/memory/__stack_pointer + local.get $instruction + i32.const 10 + call $~lib/number/U8#toString + local.tee $6 + i32.store offset=20 + i32.const 17328 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 1 + local.get $6 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 17328 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 14400 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipBytes + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + local.get $i + i32.const 1 + i32.add + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $skipBytes + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + i32.const 42 + i32.const 0 + call $~lib/rt/__newArray + local.tee $9 + i32.store offset=28 + local.get $9 + i32.const 0 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:a + call $~lib/array/Array#__set + local.get $9 + i32.const 1 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:b + call $~lib/array/Array#__set + local.get $9 + i32.const 2 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:c + call $~lib/array/Array#__set + local.get $9 + i32.const 3 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:d + call $~lib/array/Array#__set + local.get $9 + local.tee $argsArray + i32.store offset=32 + global.get $assembly/arguments/RELEVANT_ARGS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $iData + call $assembly/instructions/Instruction#get:kind + call $~lib/array/Array#__get + local.set $relevantArgs + i32.const 0 + local.set $i|12 + loop $for-loop|1 + local.get $i|12 + local.get $relevantArgs + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $~lib/memory/__stack_pointer + local.get $argsArray + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + local.get $i|12 + call $~lib/array/Array#__get + i32.const 10 + call $~lib/number/U32#toString + local.tee $13 + i32.store offset=36 + i32.const 17424 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 1 + local.get $13 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 17424 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 14400 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + local.get $i|12 + i32.const 1 + i32.add + local.set $i|12 + br $for-loop|1 + end + end + local.get $i + local.get $skipBytes + i32.add + local.set $i + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + ) + (func $assembly/codec/Decoder#u24 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 3 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 3 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u16 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 2 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.const 15 + i32.and + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u32 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 4 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 3 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 4 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#isExhausted (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#get:offset + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $assembly/codec/Decoder#get:source + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + i32.ge_s + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $assembly/codec/Decoder#finish (param $this i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + i32.const 17456 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + call $assembly/codec/Decoder#get:source + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/codec/Decoder#get:offset + i32.sub + i32.const 10 + call $~lib/number/I32#toString + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/string/String#concat + i32.const 16384 + i32.const 31 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/decodeSpi (param $data i32) (result i32) + (local $decoder i32) + (local $roLength i32) + (local $rwLength i32) + (local $_heapPages i32) + (local $_stackSize i32) + (local $_roMem i32) + (local $_rwMem i32) + (local $codeLength i32) + (local $code i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#u24 + local.set $roLength + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#u24 + local.set $rwLength + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#u16 + local.set $_heapPages + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#u24 + local.set $_stackSize + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $roLength + call $assembly/codec/Decoder#bytes + local.tee $_roMem + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $rwLength + call $assembly/codec/Decoder#bytes + local.tee $_rwMem + i32.store offset=12 + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#u32 + local.set $codeLength + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $codeLength + call $assembly/codec/Decoder#bytes + local.tee $code + i32.store offset=16 + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#finish + local.get $code + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/program/deblob + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $assembly/index/disassemble (param $input i32) (param $kind i32) (param $withMetadata i32) (result i32) + (local $program i32) + (local $output i32) + (local $data i32) + (local $p i32) + (local $p|7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $input + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/program/liftBytes + local.tee $program + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 14400 + local.tee $output + i32.store offset=8 + local.get $withMetadata + global.get $assembly/index/HasMetadata.Yes + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/program/extractCodeAndMetadata + local.tee $data + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/program/CodeAndMetadata#get:code + local.tee $program + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 16656 + local.tee $output + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $output + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 16704 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String.__concat + local.tee $output + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $output + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=32 + local.get $8 + call $assembly/program/CodeAndMetadata#get:metadata + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=20 + local.get $8 + i32.const 16736 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 14400 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/typedarray/Uint8Array#reduce<~lib/string/String> + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String.__concat + local.tee $output + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $output + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 16768 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String.__concat + local.tee $output + i32.store offset=8 + end + local.get $kind + global.get $assembly/index/InputKind.Generic + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/program/deblob + local.tee $p + i32.store offset=36 + local.get $output + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $p + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=20 + local.get $8 + call $assembly/api-generic/getAssembly + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String.__concat + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $kind + global.get $assembly/index/InputKind.SPI + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/program/decodeSpi + local.tee $p|7 + i32.store offset=40 + local.get $output + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $p|7 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=20 + local.get $8 + call $assembly/api-generic/getAssembly + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String.__concat + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + i32.const 17584 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $bufferSize i32) + (local $buffer i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 43 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:length_ + local.get $length + i32.const 1073741820 + i32.const 3 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8128 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + local.tee $2 + i32.const 8 + local.tee $3 + local.get $2 + local.get $3 + i32.gt_u + select + i32.const 3 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $bufferSize + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $length + call $~lib/array/Array#set:length_ + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $~lib/array/Array#fill (param $this i32) (param $value i64) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.get $value + local.get $start + local.get $end + call $~lib/util/bytes/FILL + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/array/Array#fill@varargs (param $this i32) (param $value i64) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $start + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $value + local.get $start + local.get $end + call $~lib/array/Array#fill + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/api-generic/VmInput#constructor (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 47 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/array/Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i64.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/array/Array#fill@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/api-generic/VmInput#set:registers + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/api-generic/VmInput#set:pc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i64.const 0 + call $assembly/api-generic/VmInput#set:gas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 17632 + call $~lib/rt/__newArray + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/api-generic/VmInput#set:program + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 17664 + call $~lib/rt/__newArray + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/api-generic/VmInput#set:pageMap + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 17696 + call $~lib/rt/__newArray + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/api-generic/VmInput#set:memory + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i64) + (local $value i64) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $"~lib/map/Map#constructor" (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.const 18 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 4 + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + i32.const 1 + i32.sub + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 4 + block $"~lib/map/ENTRY_SIZE|inlined.5" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.5" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesOffset" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/typedarray/Uint8Array.wrap (param $buffer i32) (param $byteOffset i32) (param $length i32) (result i32) + (local $buffer|3 i32) + (local $byteOffset|4 i32) + (local $len i32) + (local $byteLength i32) + (local $bufferByteLength i32) + (local $out i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + block $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) + global.get $~lib/memory/__stack_pointer + local.get $buffer + local.tee $buffer|3 + i32.store + local.get $byteOffset + local.set $byteOffset|4 + local.get $length + local.set $len + local.get $buffer|3 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/arraybuffer/ArrayBuffer#get:byteLength + local.set $bufferByteLength + local.get $byteOffset|4 + local.get $bufferByteLength + i32.gt_u + local.get $byteOffset|4 + i32.const 0 + i32.and + i32.or + if + i32.const 480 + i32.const 720 + i32.const 1860 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $len + i32.const 0 + i32.lt_s + if + local.get $len + i32.const -1 + i32.eq + if + local.get $bufferByteLength + i32.const 0 + i32.and + if + i32.const 8176 + i32.const 720 + i32.const 1865 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + local.get $bufferByteLength + local.get $byteOffset|4 + i32.sub + local.set $byteLength + else + i32.const 8176 + i32.const 720 + i32.const 1869 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + else + local.get $len + i32.const 0 + i32.shl + local.set $byteLength + local.get $byteOffset|4 + local.get $byteLength + i32.add + local.get $bufferByteLength + i32.gt_s + if + i32.const 8176 + i32.const 720 + i32.const 1874 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=8 + local.get $out + local.get $buffer|3 + i32.store + local.get $out + local.get $buffer|3 + i32.const 0 + call $~lib/rt/itcms/__link + local.get $out + local.get $byteLength + i32.store offset=8 + local.get $out + local.get $buffer|3 + local.get $byteOffset|4 + i32.add + i32.store offset=4 + local.get $out + br $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" + end + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $~lib/array/Array#unshift (param $this i32) (param $value i32) (result i32) + (local $len i32) + (local $ptr i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.set $ptr + local.get $ptr + i32.const 4 + i32.add + local.get $ptr + local.get $len + i32.const 1 + i32.sub + i32.const 2 + i32.shl + memory.copy + local.get $ptr + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory-page/Arena#constructor (param $this i32) (param $pageCount i32) (result i32) + (local $2 i32) + (local $data i32) + (local $i i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 16 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:free + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:arenaBytes + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:extraPageIndex + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/memory-page/PAGE_SIZE + local.get $pageCount + i32.mul + call $assembly/memory-page/Arena#set:arenaBytes + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + i32.const 2 + i32.const 17 + i32.const 17728 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory-page/Arena#set:free + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pageCount + call $assembly/memory-page/Arena#set:extraPageIndex + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory-page/Arena#get:arenaBytes + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $data + i32.store offset=12 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pageCount + i32.lt_s + if + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory-page/Arena#get:free + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + local.get $i + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array.wrap + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory-page/RawPage#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/array/Array#unshift + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/memory/MemoryBuilder#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 50 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#constructor" + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/MemoryBuilder#set:pages + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 128 + call $assembly/memory-page/Arena#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/MemoryBuilder#set:arena + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.set $sourceStart + i32.const 0 + i32.eqz + drop + local.get $targetStart + local.get $sourceStart + local.get $sourceLen + i32.const 0 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/MemoryBuilder#setData (param $this i32) (param $access i32) (param $address i32) (param $data i32) (result i32) + (local $currentAddress i32) + (local $currentData i32) + (local $pageIdx i32) + (local $page i32) + (local $relAddress i32) + (local $page|9 i32) + (local $spaceInPage i32) + (local $end i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + local.get $address + local.set $currentAddress + global.get $~lib/memory/__stack_pointer + local.get $data + local.tee $currentData + i32.store + loop $while-continue|0 + local.get $currentData + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + i32.gt_s + if + local.get $currentAddress + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $pageIdx + local.get $pageIdx + global.get $assembly/memory-page/RESERVED_PAGES + i32.lt_u + if + i32.const 17760 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $pageIdx + i32.const 10 + call $~lib/number/U32#toString + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/string/String#concat + i32.const 17856 + i32.const 67 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $assembly/memory/MemoryBuilder#get:pages + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $pageIdx + call $"~lib/map/Map#has" + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $assembly/memory/MemoryBuilder#get:arena + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=12 + local.get $this + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=16 + local.get $12 + call $assembly/memory/MemoryBuilder#get:pages + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $pageIdx + i32.const 0 + local.get $access + local.get $page + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=16 + local.get $12 + call $assembly/memory-page/Page#constructor + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $"~lib/map/Map#set" + drop + end + local.get $currentAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.rem_u + local.set $relAddress + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $assembly/memory/MemoryBuilder#get:pages + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $pageIdx + call $"~lib/map/Map#get" + local.tee $page|9 + i32.store offset=20 + global.get $assembly/memory-page/PAGE_SIZE + local.get $relAddress + i32.sub + local.set $spaceInPage + local.get $currentData + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + local.get $spaceInPage + i32.lt_u + if (result i32) + local.get $currentData + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + else + local.get $spaceInPage + end + local.set $end + local.get $page|9 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=24 + local.get $12 + call $assembly/memory-page/Page#get:raw + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=16 + local.get $12 + call $assembly/memory-page/RawPage#get:data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $currentData + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=16 + local.get $12 + i32.const 0 + local.get $end + call $~lib/typedarray/Uint8Array#subarray + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + local.get $relAddress + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $currentAddress + local.get $end + i32.add + local.set $currentAddress + global.get $~lib/memory/__stack_pointer + local.get $currentData + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $end + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $currentData + i32.store + br $while-continue|0 + end + end + local.get $this + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory/Memory#constructor (param $this i32) (param $arena i32) (param $pages i32) (param $sbrkAddress i32) (result i32) + (local $sbrkPage i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 15 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $arena + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory/Memory#set:arena + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory/Memory#set:pages + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $sbrkAddress + call $assembly/memory/Memory#set:sbrkAddress + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $sbrkAddress + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $sbrkPage + local.get $sbrkPage + global.get $assembly/memory-page/RESERVED_PAGES + i32.lt_u + if + i32.const 17920 + i32.const 17856 + i32.const 104 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $sbrkPage + call $"~lib/map/Map#has" + if (result i32) + local.get $sbrkPage + else + local.get $sbrkPage + i32.const 1 + i32.sub + end + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/memory/MemoryBuilder#build (param $this i32) (param $sbrkAddress i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + i32.const 0 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MemoryBuilder#get:arena + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MemoryBuilder#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $sbrkAddress + call $assembly/memory/Memory#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api-generic/buildMemory (param $builder i32) (param $pages i32) (param $chunks i32) (result i32) + (local $sbrkIndex i32) + (local $i i32) + (local $initPage i32) + (local $i|6 i32) + (local $initChunk i32) + (local $data i32) + (local $i|9 i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $assembly/memory-page/RESERVED_MEMORY + local.set $sbrkIndex + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pages + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/array/Array#get:length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $pages + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $i + call $~lib/array/Array#__get + local.tee $initPage + i32.store offset=4 + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-generic/InitialPage#get:access + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-generic/InitialPage#get:address + i32.const 0 + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-generic/InitialPage#get:length + call $~lib/typedarray/Uint8Array#constructor + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/MemoryBuilder#setData + drop + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/api-generic/InitialPage#get:access + global.get $assembly/memory-page/Access.Write + i32.eq + if + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/api-generic/InitialPage#get:address + local.get $sbrkIndex + i32.lt_u + if (result i32) + local.get $sbrkIndex + else + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/api-generic/InitialPage#get:address + end + local.set $sbrkIndex + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|6 + loop $for-loop|1 + local.get $i|6 + local.get $chunks + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/array/Array#get:length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $chunks + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $i|6 + call $~lib/array/Array#__get + local.tee $initChunk + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $initChunk + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/api-generic/InitialChunk#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $data + i32.store offset=20 + i32.const 0 + local.set $i|9 + loop $for-loop|2 + local.get $i|9 + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $i|9 + local.get $initChunk + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-generic/InitialChunk#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + local.get $i|9 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $i|9 + i32.const 1 + i32.add + local.set $i|9 + br $for-loop|2 + end + end + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + global.get $assembly/memory-page/Access.None + local.get $initChunk + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-generic/InitialChunk#get:address + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/MemoryBuilder#setData + drop + local.get $i|6 + i32.const 1 + i32.add + local.set $i|6 + br $for-loop|1 + end + end + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $sbrkIndex + call $assembly/memory/MemoryBuilder#build + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $assembly/gas/GasCounterU64#constructor (param $this i32) (param $gas i64) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 51 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $gas + call $assembly/gas/GasCounterU64#set:gas + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/interpreter/Interpreter#constructor (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 33 + i32.const 29 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:program + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:registers + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:memory + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:gas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:pc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:exitCode + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:nextPc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:useSbrkGas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/interpreter/Interpreter#set:program + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/interpreter/Interpreter#set:registers + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/interpreter/Interpreter#set:memory + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i64.const 0 + call $assembly/gas/gasCounter + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/interpreter/Interpreter#set:gas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:pc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + global.get $assembly/interpreter/Status.OK + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:exitCode + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:nextPc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:useSbrkGas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/string/String#substring (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $len i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $finalStart i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $finalEnd i32) + (local $14 i32) + (local $15 i32) + (local $fromPos i32) + (local $17 i32) + (local $18 i32) + (local $toPos i32) + (local $size i32) + (local $out i32) + (local $22 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $~lib/string/String#get:length + local.set $len + local.get $start + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + local.tee $6 + local.get $len + local.tee $7 + local.get $6 + local.get $7 + i32.lt_s + select + local.set $finalStart + local.get $end + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_s + select + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + local.set $finalEnd + local.get $finalStart + local.tee $14 + local.get $finalEnd + local.tee $15 + local.get $14 + local.get $15 + i32.lt_s + select + i32.const 1 + i32.shl + local.set $fromPos + local.get $finalStart + local.tee $17 + local.get $finalEnd + local.tee $18 + local.get $17 + local.get $18 + i32.gt_s + select + i32.const 1 + i32.shl + local.set $toPos + local.get $toPos + local.get $fromPos + i32.sub + local.set $size + local.get $size + i32.eqz + if + i32.const 14400 + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + end + local.get $fromPos + i32.eqz + if (result i32) + local.get $toPos + local.get $len + i32.const 1 + i32.shl + i32.eq + else + i32.const 0 + end + if + local.get $this + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + end + global.get $~lib/memory/__stack_pointer + local.get $size + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $out + local.get $this + local.get $fromPos + i32.add + local.get $size + memory.copy + local.get $out + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + ) + (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $value i64) + (local $sepLen i32) + (local $estLen i32) + (local $result i32) + (local $offset i32) + (local $value|9 i64) + (local $i i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 14400 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $lastIndex + i32.eqz + if + local.get $dataStart + i64.load + local.set $value + i32.const 0 + drop + i32.const 8 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 10 + call $~lib/util/number/utoa64 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $separator + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + local.set $sepLen + i32.const 20 + local.get $sepLen + i32.add + local.get $lastIndex + i32.mul + i32.const 20 + i32.add + local.set $estLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=4 + i32.const 0 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $lastIndex + i32.lt_s + if + local.get $dataStart + local.get $i + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $dataStart + local.get $lastIndex + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $estLen + local.get $offset + i32.gt_s + if + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.const 0 + local.get $offset + call $~lib/string/String#substring + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/staticarray/StaticArray#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 0 + drop + i32.const 1 + drop + local.get $this + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/staticarray/StaticArray#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/util/string/joinIntegerArray + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api-generic/runVm~anonymous|0 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 16704 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $x + i32.const 16 + call $~lib/number/U64#toString + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/string/String#concat + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $this i32) (param $fn i32) (result i32) + (local $len i32) + (local $out i32) + (local $outStart i32) + (local $i i32) + (local $result i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/staticarray/StaticArray#get:length + local.set $len + global.get $~lib/memory/__stack_pointer + local.get $len + i32.const 2 + i32.const 52 + i32.const 0 + call $~lib/rt/__newArray + local.tee $out + i32.store offset=4 + local.get $out + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.set $outStart + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.get $i + i32.const 3 + i32.shl + i32.add + i64.load + local.get $i + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + i32.const 3 + global.set $~argumentsLength + local.get $fn + i32.load + call_indirect (type $17) + local.tee $result + i32.store offset=8 + local.get $outStart + local.get $i + i32.const 2 + i32.shl + i32.add + local.get $result + i32.store + i32.const 1 + drop + local.get $out + local.get $result + i32.const 1 + call $~lib/rt/itcms/__link + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $out + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $~lib/array/Array<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) + (local $ptr i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.set $ptr + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array<~lib/string/String>#get:length_ + local.set $len + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + i32.const 1 + i32.lt_s + drop + i32.const 1 + drop + local.get $ptr + local.get $len + local.get $separator + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/util/string/joinStringArray + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-generic/runVm~anonymous|1 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 16704 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $x + i32.const 16 + call $~lib/number/U64#toString + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/string/String#concat + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/program/ResolvedArguments#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.const 54 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:a + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:b + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:c + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:d + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/program/ResolvedArguments#set:decoded + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/program/resolveArguments (param $kind i32) (param $data i32) (param $lim i32) (param $registers i32) (result i32) + (local $args i32) + (local $resolved i32) + (local $6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $kind + local.get $data + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $lim + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=4 + local.get $args + i32.const 0 + i32.eq + if + i32.const 0 + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/program/ResolvedArguments#constructor + local.tee $resolved + i32.store offset=8 + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/program/ResolvedArguments#set:decoded + block $case13|0 + block $case12|0 + block $case11|0 + block $case10|0 + block $case9|0 + block $case8|0 + block $case7|0 + block $case6|0 + block $case5|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $kind + local.set $6 + local.get $6 + global.get $assembly/arguments/Arguments.Zero + i32.eq + br_if $case0|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneImm + i32.eq + br_if $case1|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoImm + i32.eq + br_if $case2|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneOff + i32.eq + br_if $case3|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegOneImm + i32.eq + br_if $case4|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegOneExtImm + i32.eq + br_if $case5|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i32.eq + br_if $case6|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i32.eq + br_if $case7|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoReg + i32.eq + br_if $case8|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i32.eq + br_if $case9|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i32.eq + br_if $case10|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoRegTwoImm + i32.eq + br_if $case11|0 + local.get $6 + global.get $assembly/arguments/Arguments.ThreeReg + i32.eq + br_if $case12|0 + br $case13|0 + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + i64.const 32 + i64.shl + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + i64.add + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:d + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:d + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + i32.const 18528 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $~lib/string/String#concat + i32.const 18608 + i32.const 347 + i32.const 7 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/interpreter/DjumpResult#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 55 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/interpreter/DjumpStatus.OK + call $assembly/interpreter/DjumpResult#set:status + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/interpreter/DjumpResult#set:newPc + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/interpreter/dJump (param $jumpTable i32) (param $address i32) (result i32) + (local $r i32) + (local $index i32) + (local $newPc i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/interpreter/DjumpResult#constructor + local.tee $r + i32.store + local.get $address + global.get $assembly/interpreter/EXIT + i32.eq + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.HALT + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $address + i32.const 0 + i32.eq + if (result i32) + i32.const 1 + else + local.get $address + global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR + i32.rem_u + i32.const 0 + i32.ne + end + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.PANIC + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $address + global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR + i32.div_u + i32.const 1 + i32.sub + local.set $index + local.get $index + local.get $jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/JumpTable#get:jumps + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.PANIC + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/JumpTable#get:jumps + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $index + call $~lib/staticarray/StaticArray#__get + local.set $newPc + local.get $newPc + global.get $assembly/interpreter/MAX_U32 + i64.ge_u + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.PANIC + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $newPc + i32.wrap_i64 + call $assembly/interpreter/DjumpResult#set:newPc + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/interpreter/BranchResult#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 56 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/interpreter/BranchResult#set:isOkay + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/interpreter/BranchResult#set:newPc + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/program/BasicBlocks#isStart (param $this i32) (param $newPc i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $newPc + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i32.lt_u + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $newPc + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.START + i32.and + i32.const 0 + i32.gt_s + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/interpreter/branch (param $basicBlocks i32) (param $pc i32) (param $offset i32) (result i32) + (local $r i32) + (local $newPc i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/interpreter/BranchResult#constructor + local.tee $r + i32.store + local.get $pc + local.get $offset + i32.add + local.set $newPc + local.get $basicBlocks + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $newPc + call $assembly/program/BasicBlocks#isStart + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + call $assembly/interpreter/BranchResult#set:isOkay + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $newPc + call $assembly/interpreter/BranchResult#set:newPc + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/interpreter/Interpreter#nextStep (param $this i32) (result i32) + (local $pc i32) + (local $instruction i32) + (local $iData i32) + (local $skipBytes i32) + (local $args i32) + (local $alloc i64) + (local $gas i64) + (local $exe i32) + (local $outcome i32) + (local $10 i32) + (local $res i32) + (local $branchResult i32) + (local $branchResult|13 i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:status + global.get $assembly/interpreter/Status.HOST + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OK + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:nextPc + call $assembly/interpreter/Interpreter#set:pc + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const -1 + call $assembly/interpreter/Interpreter#set:nextPc + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:status + global.get $assembly/interpreter/Status.OK + i32.ne + if + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:nextPc + i32.const -1 + i32.ne + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:nextPc + call $assembly/interpreter/Interpreter#set:pc + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const -1 + call $assembly/interpreter/Interpreter#set:nextPc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const 0 + call $assembly/interpreter/Interpreter#set:exitCode + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:pc + local.set $pc + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $pc + call $assembly/program/Mask#isInstruction + i32.eqz + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $assembly/instructions/Instruction#get:gas + call $assembly/gas/GasCounter#sub@override + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OOG + call $assembly/interpreter/Interpreter#set:status + else + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + end + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $pc + call $~lib/typedarray/Uint8Array#__get + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/array/Array#get:length + i32.lt_s + if (result i32) + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $instruction + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $iData + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $iData + call $assembly/instructions/Instruction#get:gas + call $assembly/gas/GasCounter#sub@override + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OOG + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $iData + global.get $assembly/instructions/MISSING_INSTRUCTION + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $pc + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipBytes + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + local.get $pc + i32.const 1 + i32.add + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $skipBytes + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=16 + local.get $iData + global.get $assembly/instructions/SBRK + i32.eq + if (result i32) + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:useSbrkGas + else + i32.const 0 + end + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:registers + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + local.set $alloc + local.get $alloc + global.get $assembly/memory-page/PAGE_SIZE + i64.extend_i32_u + i64.add + i64.const 1 + i64.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i64.extend_i32_s + i64.shr_u + i64.const 16 + i64.mul + local.set $gas + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $gas + call $assembly/gas/GasCounter#sub@override + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OOG + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions-exe/RUN + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $instruction + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get + local.tee $exe + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/interpreter/Interpreter#get:registers + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/interpreter/Interpreter#get:memory + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + i32.const 3 + global.set $~argumentsLength + local.get $exe + i32.load + call_indirect (type $2) + local.tee $outcome + i32.store offset=24 + block $break|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:outcome + local.set $10 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.DynamicJump + i32.eq + br_if $case0|0 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.StaticJump + i32.eq + br_if $case1|0 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.Result + i32.eq + br_if $case2|0 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.Ok + i32.eq + br_if $case3|0 + br $break|0 + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:jumpTable + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:dJump + call $assembly/interpreter/dJump + local.tee $res + i32.store offset=28 + local.get $res + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/DjumpResult#get:status + global.get $assembly/interpreter/DjumpStatus.HALT + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.HALT + call $assembly/interpreter/Interpreter#set:status + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $res + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/DjumpResult#get:status + global.get $assembly/interpreter/DjumpStatus.PANIC + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:basicBlocks + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $res + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/DjumpResult#get:newPc + i32.const 0 + call $assembly/interpreter/branch + local.tee $branchResult + i32.store offset=32 + local.get $branchResult + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/BranchResult#get:isOkay + i32.eqz + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $branchResult + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/BranchResult#get:newPc + call $assembly/interpreter/Interpreter#set:pc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:basicBlocks + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $pc + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:staticJump + call $assembly/interpreter/branch + local.tee $branchResult|13 + i32.store offset=36 + local.get $branchResult|13 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/BranchResult#get:isOkay + i32.eqz + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $branchResult|13 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/BranchResult#get:newPc + call $assembly/interpreter/Interpreter#set:pc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.HOST + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.HOST + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + call $assembly/interpreter/Interpreter#set:exitCode + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:pc + i32.const 1 + i32.add + local.get $skipBytes + i32.add + call $assembly/interpreter/Interpreter#set:nextPc + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.FAULT + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i64.const 1 + call $assembly/gas/GasCounter#sub@override + drop + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + global.get $assembly/memory-page/RESERVED_MEMORY + i32.lt_u + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + else + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.FAULT + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + call $assembly/interpreter/Interpreter#set:exitCode + end + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.FAULT_ACCESS + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i64.const 1 + call $assembly/gas/GasCounter#sub@override + drop + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.PANIC + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + call $assembly/interpreter/Interpreter#set:exitCode + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + i32.const 18944 + i32.const 18992 + i32.const 173 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:pc + i32.const 1 + local.get $skipBytes + i32.add + i32.add + call $assembly/interpreter/Interpreter#set:pc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + ) + (func $assembly/api-generic/VmOutput#constructor (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 44 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + global.get $assembly/interpreter/Status.OK + call $assembly/api-generic/VmOutput#set:status + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.const 3 + i32.const 43 + i32.const 19072 + call $~lib/rt/__newArray + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/api-generic/VmOutput#set:registers + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + call $assembly/api-generic/VmOutput#set:pc + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 19104 + call $~lib/rt/__newArray + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/api-generic/VmOutput#set:memory + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i64.const 0 + call $assembly/api-generic/VmOutput#set:gas + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + call $assembly/api-generic/VmOutput#set:exitCode + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#slice<~lib/array/Array> (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $length i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $sourceStart i32) + (local $size i32) + (local $out i32) + (local $outStart i32) + (local $18 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $18 + global.get $~lib/memory/__stack_pointer + local.get $18 + i32.store + local.get $18 + call $~lib/staticarray/StaticArray#get:length + local.set $length + local.get $start + i32.const 0 + i32.lt_s + if (result i32) + local.get $start + local.get $length + i32.add + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + else + local.get $start + local.tee $6 + local.get $length + local.tee $7 + local.get $6 + local.get $7 + i32.lt_s + select + end + local.set $start + local.get $end + i32.const 0 + i32.lt_s + if (result i32) + local.get $end + local.get $length + i32.add + local.tee $8 + i32.const 0 + local.tee $9 + local.get $8 + local.get $9 + i32.gt_s + select + else + local.get $end + local.tee $10 + local.get $length + local.tee $11 + local.get $10 + local.get $11 + i32.lt_s + select + end + local.set $end + local.get $end + local.get $start + i32.sub + local.tee $12 + i32.const 0 + local.tee $13 + local.get $12 + local.get $13 + i32.gt_s + select + local.set $length + local.get $this + local.get $start + i32.const 3 + i32.shl + i32.add + local.set $sourceStart + local.get $length + i32.const 3 + i32.shl + local.set $size + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $out + i32.store offset=4 + i32.const 1 + drop + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 3 + i32.const 43 + i32.const 0 + call $~lib/rt/__newArray + local.tee $out + i32.store offset=4 + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + local.get $18 + i32.store + local.get $18 + call $~lib/array/Array#get:dataStart + local.set $outStart + i32.const 0 + drop + local.get $outStart + local.get $sourceStart + local.get $size + memory.copy + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + ) + (func $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $start + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $start + local.get $end + call $~lib/staticarray/StaticArray#slice<~lib/array/Array> + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $bufferSize i32) + (local $buffer i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 42 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:length_ + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8128 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + local.tee $2 + i32.const 8 + local.tee $3 + local.get $2 + local.get $3 + i32.gt_u + select + i32.const 2 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $bufferSize + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $length + call $~lib/array/Array#set:length_ + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.get $newLength + i32.const 2 + i32.const 0 + call $~lib/array/ensureCapacity + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $newLength + call $~lib/array/Array#set:length_ + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#keys" (param $this i32) (result i32) + (local $start i32) + (local $size i32) + (local $keys i32) + (local $length i32) + (local $i i32) + (local $entry i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.set $start + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.set $size + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $size + call $~lib/array/Array#constructor + local.tee $keys + i32.store offset=4 + i32.const 0 + local.set $length + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $size + i32.lt_s + if + local.get $start + local.get $i + block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.6" + end + i32.mul + i32.add + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $keys + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + local.tee $7 + i32.const 1 + i32.add + local.set $length + local.get $7 + local.get $entry + call $"~lib/map/MapEntry#get:key" + call $~lib/array/Array#__set + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $keys + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + call $~lib/array/Array#set:length + local.get $keys + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 0 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-generic/InitialChunk#constructor (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 45 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + call $assembly/api-generic/InitialChunk#set:address + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 19168 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/api-generic/InitialChunk#set:data + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + i32.const 0 + drop + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 1 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-generic/getOutputChunks (param $memory i32) (result i32) + (local $1 i32) + (local $chunks i32) + (local $pages i32) + (local $currentChunk i32) + (local $i i32) + (local $pageIdx i32) + (local $page i32) + (local $n i32) + (local $v i32) + (local $10 i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 19136 + call $~lib/rt/__newArray + local.tee $chunks + i32.store + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory/Memory#get:pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $"~lib/map/Map#keys" + local.tee $pages + i32.store offset=12 + i32.const 0 + local.set $currentChunk + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/array/Array#get:length + i32.lt_s + if + block $for-continue|0 + local.get $pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $i + call $~lib/array/Array#__get + local.set $pageIdx + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory/Memory#get:pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $pageIdx + call $"~lib/map/Map#get" + local.tee $page + i32.store offset=16 + local.get $page + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory-page/Page#get:raw + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $assembly/memory-page/RawPage#get:page + i32.const 0 + i32.eq + if + br $for-continue|0 + end + i32.const 0 + local.set $n + loop $for-loop|1 + local.get $n + local.get $page + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=20 + local.get $11 + call $assembly/memory-page/Page#get:raw + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory-page/RawPage#get:data + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $page + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=20 + local.get $11 + call $assembly/memory-page/Page#get:raw + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory-page/RawPage#get:data + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + i32.const 0 + i32.ne + if + local.get $currentChunk + i32.const 0 + i32.ne + if + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/api-generic/InitialChunk#get:data + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $v + call $~lib/array/Array#push + drop + else + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-generic/InitialChunk#constructor + local.tee $currentChunk + i32.store offset=24 + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $pageIdx + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.get $n + i32.add + call $assembly/api-generic/InitialChunk#set:address + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + global.get $~lib/memory/__stack_pointer + i32.const 1 + i32.const 0 + i32.const 27 + i32.const 0 + call $~lib/rt/__newArray + local.tee $10 + i32.store offset=28 + local.get $10 + i32.const 0 + local.get $v + call $~lib/array/Array#__set + local.get $10 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/api-generic/InitialChunk#set:data + end + else + local.get $currentChunk + i32.const 0 + i32.ne + if + local.get $chunks + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $~lib/array/Array#push + drop + i32.const 0 + local.set $currentChunk + end + end + local.get $n + i32.const 1 + i32.add + local.set $n + br $for-loop|1 + end + end + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $currentChunk + i32.const 0 + i32.ne + if + local.get $chunks + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $~lib/array/Array#push + drop + end + local.get $chunks + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $bufferSize i32) + (local $buffer i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 57 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:length_ + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8128 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + local.tee $2 + i32.const 8 + local.tee $3 + local.get $2 + local.get $3 + i32.gt_u + select + i32.const 2 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $bufferSize + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $length + call $~lib/array/Array#set:length_ + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.get $newLength + i32.const 2 + i32.const 0 + call $~lib/array/ensureCapacity + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $newLength + call $~lib/array/Array#set:length_ + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#values" (param $this i32) (result i32) + (local $start i32) + (local $size i32) + (local $values i32) + (local $length i32) + (local $i i32) + (local $entry i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.set $start + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.set $size + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $size + call $~lib/array/Array#constructor + local.tee $values + i32.store offset=4 + i32.const 0 + local.set $length + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $size + i32.lt_s + if + local.get $start + local.get $i + block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.7" + end + i32.mul + i32.add + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + local.tee $7 + i32.const 1 + i32.add + local.set $length + local.get $7 + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/array/Array#__set + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + call $~lib/array/Array#set:length + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 1 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory-page/Arena#release (param $this i32) (param $page i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory-page/Arena#get:free + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $page + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/array/Array#push + drop + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#clear" (param $this i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + i32.const 4 + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 4 + i32.const 1 + i32.sub + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + i32.const 4 + block $"~lib/map/ENTRY_SIZE|inlined.8" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.8" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 4 + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesOffset" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesCount" + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#free (param $this i32) + (local $pages i32) + (local $i i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory/Memory#get:pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $"~lib/map/Map#values" + local.tee $pages + i32.store offset=8 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + i32.lt_s + if + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/memory/Memory#get:arena + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + local.get $i + call $~lib/array/Array#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/memory-page/Page#get:raw + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#release + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory/Memory#get:pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $"~lib/map/Map#clear" + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/runVm (param $input i32) (param $logs i32) (param $useSbrkGas i32) (result i32) + (local $p i32) + (local $registers i32) + (local $r i32) + (local $builder i32) + (local $memory i32) + (local $int i32) + (local $isOk i32) + (local $10 i32) + (local $11 i32) + (local $instruction i32) + (local $iData i32) + (local $skipBytes i32) + (local $name i32) + (local $16 i32) + (local $17 i32) + (local $args i32) + (local $19 i32) + (local $20 i32) + (local $21 i32) + (local $22 i32) + (local $23 i32) + (local $24 i32) + (local $25 i32) + (local $26 i32) + (local $27 i32) + (local $28 i32) + (local $29 i32) + (local $30 i32) + (local $output i32) + (local $32 i32) + global.get $~lib/memory/__stack_pointer + i32.const 124 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 124 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/api-generic/VmInput#get:program + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/liftBytes + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $assembly/program/deblob + local.tee $p + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=16 + i32.const 0 + local.set $r + loop $for-loop|0 + local.get $r + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $r + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/api-generic/VmInput#get:registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $r + call $~lib/array/Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $r + i32.const 1 + i32.add + local.set $r + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/api-generic/VmInput#get:pageMap + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/api-generic/VmInput#get:memory + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/api-generic/buildMemory + local.tee $memory + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $p + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $memory + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/interpreter/Interpreter#constructor + local.tee $int + i32.store offset=32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $useSbrkGas + call $assembly/interpreter/Interpreter#set:useSbrkGas + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/api-generic/VmInput#get:pc + call $assembly/interpreter/Interpreter#set:nextPc + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:gas + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/api-generic/VmInput#get:gas + call $assembly/gas/GasCounter#set@override + i32.const 1 + local.set $isOk + block $for-break1 + loop $for-loop|1 + i32.const 1 + if + local.get $isOk + i32.eqz + if + local.get $logs + if + global.get $~lib/memory/__stack_pointer + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 17392 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray#join + local.tee $10 + i32.store offset=36 + i32.const 18128 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 1 + local.get $10 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18128 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 14400 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + global.get $~lib/memory/__stack_pointer + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + i32.const 18192 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=40 + local.get $32 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 17392 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/array/Array<~lib/string/String>#join + local.tee $11 + i32.store offset=44 + i32.const 18160 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 1 + local.get $11 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18160 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 14400 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 18224 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:status + i32.const 10 + call $~lib/number/I32#toString + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/string/String#concat + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + br $for-break1 + end + local.get $logs + if + i32.const 18288 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + i32.const 10 + call $~lib/number/U32#toString + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/string/String#concat + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 18320 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:status + i32.const 10 + call $~lib/number/I32#toString + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/string/String#concat + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 18032 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + i32.const 17392 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=40 + local.get $32 + call $~lib/staticarray/StaticArray#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/string/String#concat + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 18032 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=48 + local.get $32 + i32.const 18368 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=52 + local.get $32 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + i32.const 17392 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=40 + local.get $32 + call $~lib/array/Array<~lib/string/String>#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/string/String#concat + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/interpreter/Interpreter#get:program + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/Program#get:code + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_u + if (result i32) + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/interpreter/Interpreter#get:program + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/Program#get:code + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + call $~lib/typedarray/Uint8Array#__get + else + i32.const 0 + end + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $instruction + call $~lib/array/Array#__get + end + local.set $iData + local.get $p + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/Program#get:mask + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipBytes + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:namePtr + local.tee $name + i32.store offset=56 + global.get $~lib/memory/__stack_pointer + local.get $name + local.tee $16 + i32.store offset=60 + global.get $~lib/memory/__stack_pointer + local.get $instruction + i32.const 10 + call $~lib/number/U8#toString + local.tee $17 + i32.store offset=64 + i32.const 18480 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 1 + local.get $16 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18480 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 3 + local.get $17 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18480 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 14400 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=40 + local.get $32 + call $assembly/interpreter/Interpreter#get:program + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/program/Program#get:code + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + i32.const 1 + i32.add + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $skipBytes + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/interpreter/Interpreter#get:registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/resolveArguments + local.tee $args + i32.store offset=68 + local.get $args + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:a + i32.const 10 + call $~lib/number/I64#toString + local.tee $19 + i32.store offset=72 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/program/ResolvedArguments#get:decoded + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/arguments/Args#get:a + i32.const 10 + call $~lib/number/U32#toString + local.tee $20 + i32.store offset=76 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:a + i32.const 16 + call $~lib/number/U64#toString + local.tee $21 + i32.store offset=80 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:b + i32.const 10 + call $~lib/number/I64#toString + local.tee $22 + i32.store offset=84 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/program/ResolvedArguments#get:decoded + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/arguments/Args#get:b + i32.const 10 + call $~lib/number/U32#toString + local.tee $23 + i32.store offset=88 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:b + i32.const 16 + call $~lib/number/U64#toString + local.tee $24 + i32.store offset=92 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:c + i32.const 10 + call $~lib/number/I64#toString + local.tee $25 + i32.store offset=96 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/program/ResolvedArguments#get:decoded + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/arguments/Args#get:c + i32.const 10 + call $~lib/number/U32#toString + local.tee $26 + i32.store offset=100 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:c + i32.const 16 + call $~lib/number/U64#toString + local.tee $27 + i32.store offset=104 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:d + i32.const 10 + call $~lib/number/I64#toString + local.tee $28 + i32.store offset=108 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/program/ResolvedArguments#get:decoded + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/arguments/Args#get:d + i32.const 10 + call $~lib/number/U32#toString + local.tee $29 + i32.store offset=112 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:d + i32.const 16 + call $~lib/number/U64#toString + local.tee $30 + i32.store offset=116 + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 1 + local.get $19 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 3 + local.get $20 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 5 + local.get $21 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 7 + local.get $22 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 9 + local.get $23 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 11 + local.get $24 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 13 + local.get $25 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 15 + local.get $26 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 17 + local.get $27 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 19 + local.get $28 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 21 + local.get $29 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 23 + local.get $30 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 14400 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + end + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $assembly/interpreter/Interpreter#nextStep + local.set $isOk + br $for-loop|1 + end + end + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-generic/VmOutput#constructor + local.tee $output + i32.store offset=120 + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:status + call $assembly/api-generic/VmOutput#set:status + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/api-generic/VmOutput#set:registers + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + call $assembly/api-generic/VmOutput#set:pc + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/interpreter/Interpreter#get:gas + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/gas/GasCounter#get@override + call $assembly/api-generic/VmOutput#set:gas + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:memory + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/api-generic/getOutputChunks + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/api-generic/VmOutput#set:memory + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:exitCode + call $assembly/api-generic/VmOutput#set:exitCode + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:memory + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $assembly/memory/Memory#free + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + i32.const 124 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $32 + return + ) + (func $assembly/index/runProgram (param $input i32) (param $registers i32) (param $kind i32) (result i32) + (local $vmInput i32) + (local $output i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $kind + global.get $assembly/index/InputKind.Generic + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-generic/VmInput#constructor + local.tee $vmInput + i32.store + local.get $vmInput + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/api-generic/VmInput#set:registers + local.get $vmInput + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i64.const 10000 + call $assembly/api-generic/VmInput#set:gas + local.get $vmInput + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $input + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/api-generic/VmInput#set:program + global.get $~lib/memory/__stack_pointer + local.get $vmInput + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + i32.const 0 + call $assembly/api-generic/runVm + local.tee $output + i32.store offset=12 + i32.const 18224 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $output + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/api-generic/VmOutput#get:status + i32.const 10 + call $~lib/number/I32#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $~lib/string/String#concat + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/console/console.log + local.get $output + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $kind + global.get $assembly/index/InputKind.SPI + i32.eq + if + i32.const 19200 + i32.const 19280 + i32.const 57 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + i32.const 17584 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/string/String#concat + i32.const 19280 + i32.const 60 + i32.const 3 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api-generic/runVm@varargs (param $input i32) (param $logs i32) (param $useSbrkGas i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $logs + end + i32.const 0 + local.set $useSbrkGas + end + local.get $input + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $logs + local.get $useSbrkGas + call $assembly/api-generic/runVm + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program-build/skipBytes (param $kind i32) (param $data i32) (result i32) + (local $2 i32) + (local $n i32) + (local $split i32) + (local $n|5 i32) + (local $split|6 i32) + (local $n|7 i32) + (local $split|8 i32) + (local $value1 f64) + (local $value2 f64) + (local $value1|11 f64) + (local $value2|12 f64) + (local $n|13 i32) + (local $split|14 i32) + (local $15 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $case13|0 + block $case12|0 + block $case11|0 + block $case10|0 + block $case9|0 + block $case8|0 + block $case7|0 + block $case6|0 + block $case5|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $kind + local.set $2 + local.get $2 + global.get $assembly/arguments/Arguments.Zero + i32.eq + br_if $case0|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneImm + i32.eq + br_if $case1|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoImm + i32.eq + br_if $case2|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneOff + i32.eq + br_if $case3|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegOneImm + i32.eq + br_if $case4|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegOneExtImm + i32.eq + br_if $case5|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i32.eq + br_if $case6|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i32.eq + br_if $case7|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoReg + i32.eq + br_if $case8|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i32.eq + br_if $case9|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i32.eq + br_if $case10|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoRegTwoImm + i32.eq + br_if $case11|0 + local.get $2 + global.get $assembly/arguments/Arguments.ThreeReg + i32.eq + br_if $case12|0 + br $case13|0 + end + i32.const 0 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + call $assembly/program-build/immBytes + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:low + i32.const 1 + i32.add + local.set $split + i32.const 1 + local.get $split + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + local.get $split + i32.const 1 + i32.add + i32.const 255 + i32.and + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + call $assembly/program-build/immBytes + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 9 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n|5 + i32.store offset=8 + local.get $n|5 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:hig + i32.const 1 + i32.add + local.set $split|6 + i32.const 1 + local.get $split|6 + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + local.get $split|6 + i32.const 255 + i32.and + i32.add + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n|7 + i32.store offset=12 + local.get $n|7 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:hig + i32.const 1 + i32.add + local.set $split|8 + i32.const 1 + local.get $split|8 + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + local.get $split|8 + i32.const 255 + i32.and + i32.add + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + block $~lib/math/NativeMath.min|inlined.5 (result f64) + f64.const 4 + local.set $value1 + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.5 + end + i32.trunc_sat_f64_s + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + block $~lib/math/NativeMath.min|inlined.6 (result f64) + f64.const 4 + local.set $value1|11 + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + local.set $value2|12 + local.get $value1|11 + local.get $value2|12 + f64.min + br $~lib/math/NativeMath.min|inlined.6 + end + i32.trunc_sat_f64_s + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n|13 + i32.store offset=16 + local.get $n|13 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:low + i32.const 1 + i32.add + local.set $split|14 + i32.const 2 + local.get $split|14 + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 2 + local.get $split|14 + i32.const 255 + i32.and + i32.add + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 2 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 18528 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store offset=20 + local.get $15 + call $~lib/string/String#concat + i32.const 19344 + i32.const 73 + i32.const 7 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program-build/buildMask (param $bytecode i32) (result i32) + (local $mask i32) + (local $i i32) + (local $instruction i32) + (local $iData i32) + (local $requiredBytes i32) + (local $6 i32) + (local $packed i32) + (local $i|8 i32) + (local $byte i32) + (local $j i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + call $~lib/staticarray/StaticArray#constructor + local.tee $mask + i32.store offset=4 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/array/Array#get:length + i32.lt_s + if (result i32) + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $instruction + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $iData + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $i + i32.const 1 + call $~lib/staticarray/StaticArray#__set + global.get $assembly/arguments/REQUIRED_BYTES + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $iData + call $assembly/instructions/Instruction#get:kind + call $~lib/array/Array#__get + local.set $requiredBytes + local.get $i + i32.const 1 + i32.add + local.get $requiredBytes + i32.add + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + i32.le_s + if + local.get $i + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + local.get $i + i32.const 1 + i32.add + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $assembly/program-build/skipBytes + i32.add + local.set $i + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 19424 + call $~lib/rt/__newArray + local.tee $packed + i32.store offset=12 + i32.const 0 + local.set $i|8 + loop $for-loop|1 + local.get $i|8 + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + i32.const 0 + local.set $byte + local.get $i|8 + local.set $j + loop $for-loop|3 + local.get $j + local.get $i|8 + i32.const 8 + i32.add + i32.lt_s + if + local.get $byte + i32.const 255 + i32.and + i32.const 1 + i32.const 7 + i32.and + i32.shr_u + local.set $byte + local.get $j + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if (result i32) + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $j + call $~lib/staticarray/StaticArray#__get + else + i32.const 0 + end + if + local.get $byte + i32.const 128 + i32.or + local.set $byte + end + local.get $j + i32.const 1 + i32.add + local.set $j + br $for-loop|3 + end + end + local.get $packed + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $byte + call $~lib/array/Array#push + drop + local.get $i|8 + i32.const 8 + i32.add + local.set $i|8 + br $for-loop|1 + end + end + local.get $packed + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/dataview/DataView#constructor (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) + (local $dataStart i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 59 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $~lib/dataview/DataView#set:buffer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $~lib/dataview/DataView#set:dataStart + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $~lib/dataview/DataView#set:byteLength + local.get $byteLength + i32.const 1073741820 + i32.gt_u + local.get $byteOffset + local.get $byteLength + i32.add + local.get $buffer + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/arraybuffer/ArrayBuffer#get:byteLength + i32.gt_u + i32.or + if + i32.const 8176 + i32.const 19456 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $buffer + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/dataview/DataView#set:buffer + local.get $buffer + local.get $byteOffset + i32.add + local.set $dataStart + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $dataStart + call $~lib/dataview/DataView#set:dataStart + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $byteLength + call $~lib/dataview/DataView#set:byteLength + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $~lib/dataview/DataView#constructor@varargs (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $byteOffset + end + local.get $buffer + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/arraybuffer/ArrayBuffer#get:byteLength + local.set $byteLength + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $buffer + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $byteOffset + local.get $byteLength + call $~lib/dataview/DataView#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/dataview/DataView#setUint64 (param $this i32) (param $byteOffset i32) (param $value i64) (param $littleEndian i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $byteOffset + i32.const 31 + i32.shr_u + local.get $byteOffset + i32.const 8 + i32.add + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/dataview/DataView#get:byteLength + i32.gt_s + i32.or + if + i32.const 480 + i32.const 19456 + i32.const 174 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/dataview/DataView#get:dataStart + local.get $byteOffset + i32.add + local.get $littleEndian + if (result i64) + local.get $value + else + local.get $value + call $~lib/polyfills/bswap + end + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/encodeVarU32 (param $v i64) (result i32) + (local $maxEncoded i64) + (local $dest i32) + (local $dataView i32) + (local $minEncoded i64) + (local $l i32) + (local $dest|6 i32) + (local $maxVal i32) + (local $byte i64) + (local $rest i64) + (local $i i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + local.get $v + i64.const 0 + i64.eq + if + i32.const 0 + i32.const 1 + call $~lib/typedarray/Uint8Array#constructor + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + i64.const 2 + i64.const 7 + i64.const 8 + i64.mul + call $~lib/math/ipow64 + local.set $maxEncoded + local.get $v + local.get $maxEncoded + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 9 + call $~lib/typedarray/Uint8Array#constructor + local.tee $dest + i32.store + local.get $dest + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + i32.const 255 + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $dest + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/dataview/DataView#constructor@varargs + local.tee $dataView + i32.store offset=12 + local.get $dataView + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 1 + local.get $v + i32.const 1 + call $~lib/dataview/DataView#setUint64 + local.get $dest + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $maxEncoded + i64.const 7 + i64.shr_u + local.set $minEncoded + i32.const 7 + local.set $l + loop $for-loop|0 + local.get $l + i32.const 0 + i32.ge_s + if + local.get $v + local.get $minEncoded + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $l + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $dest|6 + i32.store offset=16 + i32.const 2 + i32.const 8 + local.get $l + i32.mul + call $~lib/math/ipow32 + local.set $maxVal + i32.const 2 + i32.const 8 + call $~lib/math/ipow32 + i32.const 2 + i32.const 8 + local.get $l + i32.sub + call $~lib/math/ipow32 + i32.sub + i64.extend_i32_s + local.get $v + local.get $maxVal + i64.extend_i32_s + i64.div_u + i64.add + local.set $byte + local.get $dest|6 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + local.get $byte + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + local.get $maxVal + i64.extend_i32_s + i64.rem_u + local.set $rest + i32.const 1 + local.set $i + loop $for-loop|1 + local.get $i + i32.const 1 + local.get $l + i32.add + i32.lt_s + if + local.get $dest|6 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $i + local.get $rest + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $rest + i64.const 8 + i64.shr_u + local.set $rest + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|1 + end + end + local.get $dest|6 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $minEncoded + local.set $maxEncoded + local.get $minEncoded + i64.const 7 + i64.shr_u + local.set $minEncoded + local.get $l + i32.const 1 + i32.sub + local.set $l + br $for-loop|0 + end + end + i32.const 19520 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $v + i32.const 10 + call $~lib/number/U64#toString + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $~lib/string/String#concat + i32.const 16384 + i32.const 160 + i32.const 3 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/program-build/wrapAsProgram (param $bytecode i32) (result i32) + (local $codeLength i32) + (local $mask i32) + (local $codeLengthBytes i32) + (local $data i32) + (local $offset i32) + (local $i i32) + (local $i|7 i32) + (local $i|8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + local.get $bytecode + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.set $codeLength + global.get $~lib/memory/__stack_pointer + local.get $bytecode + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $assembly/program-build/buildMask + local.tee $mask + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $codeLength + i64.extend_i32_s + call $assembly/codec/encodeVarU32 + local.tee $codeLengthBytes + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 1 + i32.add + local.get $codeLengthBytes + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.add + local.get $codeLength + i32.add + local.get $mask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/array/Array#get:length + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $data + i32.store offset=12 + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + i32.const 2 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $codeLengthBytes + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $offset + local.get $codeLengthBytes + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $offset + i32.const 1 + i32.add + local.set $offset + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $bytecode + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $offset + local.get $bytecode + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + local.get $i|7 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $offset + i32.const 1 + i32.add + local.set $offset + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + i32.const 0 + local.set $i|8 + loop $for-loop|2 + local.get $i|8 + local.get $mask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/array/Array#get:length + i32.lt_s + if + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $offset + local.get $mask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + local.get $i|8 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $offset + i32.const 1 + i32.add + local.set $offset + local.get $i|8 + i32.const 1 + i32.add + local.set $i|8 + br $for-loop|2 + end + end + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $assembly/api/fillRegisters (param $registers i32) (param $flat i32) + (local $len i32) + (local $3 i32) + (local $4 i32) + (local $i i32) + (local $num i64) + (local $j i32) + (local $index i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/staticarray/StaticArray#get:length + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + local.set $len + local.get $len + local.get $flat + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/array/Array#get:length + i32.ne + if + global.get $~lib/memory/__stack_pointer + local.get $flat + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/array/Array#get:length + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $len + i32.const 10 + call $~lib/number/I32#toString + local.tee $4 + i32.store offset=8 + i32.const 19744 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 1 + local.get $3 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 19744 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 3 + local.get $4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 19744 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 14400 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 19792 + i32.const 166 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $registers + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + i64.const 0 + local.set $num + i32.const 0 + local.set $j + loop $for-loop|1 + local.get $j + global.get $assembly/registers/REG_SIZE_BYTES + i32.const 255 + i32.and + i32.lt_u + if + local.get $i + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + local.get $j + i32.add + local.set $index + local.get $num + local.get $flat + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $index + call $~lib/array/Array#__get + i64.extend_i32_u + local.get $j + i32.const 8 + i32.mul + i32.const 255 + i32.and + i64.extend_i32_u + i64.shl + i64.or + local.set $num + local.get $j + i32.const 1 + i32.add + local.set $j + br $for-loop|1 + end + end + local.get $registers + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $i + local.get $num + call $~lib/staticarray/StaticArray#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/interpreter/Interpreter#constructor@varargs (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 2 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $assembly/memory/MemoryBuilder#build + local.tee $memory + i32.store offset=4 + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/interpreter/Interpreter#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/api/resetGeneric (param $program i32) (param $flatRegisters i32) (param $initialGas i64) + (local $p i32) + (local $registers i32) + (local $int i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + call $assembly/program/liftBytes + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $assembly/program/deblob + local.tee $p + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=12 + local.get $registers + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $flatRegisters + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + call $assembly/api/fillRegisters + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $p + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $registers + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 2 + global.set $~argumentsLength + i32.const 0 + call $assembly/interpreter/Interpreter#constructor@varargs + local.tee $int + i32.store offset=16 + local.get $int + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + call $assembly/interpreter/Interpreter#get:gas + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $initialGas + call $assembly/gas/GasCounter#set@override + local.get $int + global.set $assembly/api/interpreter + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/InitialPage#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 48 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/api-generic/InitialPage#set:address + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/api-generic/InitialPage#set:length + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/memory-page/Access.None + call $assembly/api-generic/InitialPage#set:access + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 1 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api/readPages (param $pageMap i32) (result i32) + (local $1 i32) + (local $pages i32) + (local $codec i32) + (local $p i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 19856 + call $~lib/rt/__newArray + local.tee $pages + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $pageMap + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $codec + i32.store offset=8 + loop $while-continue|0 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-generic/InitialPage#constructor + local.tee $p + i32.store offset=12 + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/codec/Decoder#u32 + call $assembly/api-generic/InitialPage#set:address + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/codec/Decoder#u32 + call $assembly/api-generic/InitialPage#set:length + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/codec/Decoder#u8 + i32.const 0 + i32.gt_u + if (result i32) + global.get $assembly/memory-page/Access.Write + else + global.get $assembly/memory-page/Access.Read + end + call $assembly/api-generic/InitialPage#set:access + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $~lib/array/Array#push + drop + br $while-continue|0 + end + end + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/api/readChunks (param $chunks i32) (result i32) + (local $1 i32) + (local $res i32) + (local $codec i32) + (local $c i32) + (local $len i32) + (local $data i32) + (local $i i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 19888 + call $~lib/rt/__newArray + local.tee $res + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $chunks + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $codec + i32.store offset=8 + loop $while-continue|0 + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-generic/InitialChunk#constructor + local.tee $c + i32.store offset=12 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $assembly/codec/Decoder#u32 + call $assembly/api-generic/InitialChunk#set:address + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/codec/Decoder#u32 + local.set $len + global.get $~lib/memory/__stack_pointer + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $len + call $assembly/codec/Decoder#bytes + local.tee $data + i32.store offset=20 + i32.const 0 + local.set $i + loop $for-loop|1 + local.get $i + local.get $len + i32.lt_u + if + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $assembly/api-generic/InitialChunk#get:data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#push + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/array/Array#push + drop + br $while-continue|0 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/api/resetGenericWithMemory (param $program i32) (param $flatRegisters i32) (param $pageMap i32) (param $chunks i32) (param $initialGas i64) + (local $p i32) + (local $registers i32) + (local $builder i32) + (local $memory i32) + (local $int i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $assembly/program/liftBytes + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/program/deblob + local.tee $p + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=12 + local.get $registers + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $flatRegisters + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $assembly/api/fillRegisters + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $pageMap + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=24 + local.get $10 + call $assembly/api/readPages + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $chunks + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=24 + local.get $10 + call $assembly/api/readChunks + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=20 + local.get $10 + call $assembly/api-generic/buildMemory + local.tee $memory + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $p + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $registers + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $memory + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=20 + local.get $10 + call $assembly/interpreter/Interpreter#constructor + local.tee $int + i32.store offset=32 + local.get $int + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $assembly/interpreter/Interpreter#get:gas + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $initialGas + call $assembly/gas/GasCounter#set@override + local.get $int + global.set $assembly/api/interpreter + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/nextStep (result i32) + (local $0 i32) + (local $int i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 19792 + i32.const 43 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/interpreter/Interpreter#nextStep + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api/nSteps (param $steps i32) (result i32) + (local $1 i32) + (local $int i32) + (local $isOk i32) + (local $i i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 51 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + i32.const 1 + local.set $isOk + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $steps + i32.lt_u + if + local.get $int + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/interpreter/Interpreter#nextStep + local.set $isOk + local.get $isOk + i32.eqz + if + i32.const 0 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $isOk + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + i32.const 0 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/api/getProgramCounter (result i32) + (local $0 i32) + (local $int i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 19792 + i32.const 68 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/interpreter/Interpreter#get:pc + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api/setNextProgramCounter (param $pc i32) + (local $1 i32) + (local $int i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 76 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $pc + call $assembly/interpreter/Interpreter#set:nextPc + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/getStatus (result i32) + (local $0 i32) + (local $int i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + global.get $assembly/interpreter/Status.PANIC + i32.const 255 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 19792 + i32.const 84 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/interpreter/Interpreter#get:status + i32.const 255 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api/getExitArg (result i32) + (local $0 i32) + (local $int i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + i32.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 19792 + i32.const 92 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/interpreter/Interpreter#get:exitCode + local.tee $2 + if (result i32) + local.get $2 + else + i32.const 0 + end + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/api/getGasLeft (result i64) + (local $0 i32) + (local $int i32) + (local $2 i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + i64.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 19792 + i32.const 100 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + call $assembly/interpreter/Interpreter#get:gas + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/gas/GasCounter#get@override + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/api/setGasLeft (param $gas i64) + (local $1 i32) + (local $int i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 106 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/interpreter/Interpreter#get:gas + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $gas + call $assembly/gas/GasCounter#set@override + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/getRegisters (result i32) + (local $flat i32) + (local $1 i32) + (local $int i32) + (local $i i32) + (local $val i64) + (local $j i32) + (local $index i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + call $~lib/typedarray/Uint8Array#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.tee $flat + i32.store offset=4 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + local.get $flat + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store offset=8 + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 117 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=12 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $int + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/interpreter/Interpreter#get:registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + local.get $int + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/interpreter/Interpreter#get:registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $i + call $~lib/staticarray/StaticArray#__get + local.set $val + i32.const 0 + local.set $j + loop $for-loop|1 + local.get $j + global.get $assembly/registers/REG_SIZE_BYTES + i32.lt_s + if + local.get $i + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + local.get $j + i32.add + local.set $index + local.get $flat + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $index + local.get $val + i64.const 255 + i64.and + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $val + i64.const 8 + i64.shr_u + local.set $val + local.get $j + i32.const 1 + i32.add + local.set $j + br $for-loop|1 + end + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $flat + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $assembly/api/setRegisters (param $flatRegisters i32) + (local $1 i32) + (local $int i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 134 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + call $assembly/interpreter/Interpreter#get:registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $flatRegisters + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/api/fillRegisters + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#pageDump (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory/Memory#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $index + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + call $assembly/memory/Memory#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + local.get $index + call $"~lib/map/Map#get" + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory-page/Page#get:raw + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:data + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api/getPageDump (param $index i32) (result i32) + (local $1 i32) + (local $int i32) + (local $page i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store offset=4 + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 142 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $int + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/interpreter/Interpreter#get:memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $index + call $assembly/memory/Memory#pageDump + local.tee $page + i32.store offset=16 + local.get $page + i32.const 0 + i32.eq + if + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $page + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api/setMemory (param $address i32) (param $data i32) + (local $2 i32) + (local $int i32) + (local $end i32) + (local $i i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $2 + i32.store + local.get $2 + if (result i32) + local.get $2 + else + i32.const 9488 + i32.const 19792 + i32.const 155 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $address + local.get $data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $~lib/typedarray/Uint8Array#get:length + i32.add + local.set $end + local.get $address + local.set $i + loop $for-loop|0 + local.get $i + local.get $end + i32.lt_u + if + local.get $int + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/interpreter/Interpreter#get:memory + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $i + local.get $data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $i + local.get $address + i32.sub + call $~lib/typedarray/Uint8Array#__get + call $assembly/memory/Memory#setU8 + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/gas/GasCounterU64#set (param $this i32) (param $g i64) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $g + call $assembly/gas/GasCounterU64#set:gas + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/gas/GasCounterU64#sub (param $this i32) (param $g i64) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/gas/GasCounterU64#get:gas + local.get $g + i64.sub + call $assembly/gas/GasCounterU64#set:gas + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/gas/GasCounterU64#get:gas + i64.const 0 + i64.lt_s + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/gas/GasCounterU64#get (param $this i32) (result i64) + (local $1 i32) + (local $2 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/gas/GasCounterU64#get:gas + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#__visit" (param $this i32) (param $cookie i32) + (local $entries i32) + (local $cur i32) + (local $end i32) + (local $entry i32) + (local $val i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:buckets" + local.get $cookie + call $~lib/rt/itcms/__visit + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:entries" + local.set $entries + i32.const 1 + drop + local.get $entries + local.set $cur + local.get $cur + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.9" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.9" + end + i32.mul + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + drop + i32.const 1 + drop + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $val + i32.const 0 + drop + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + block $"~lib/map/ENTRY_SIZE|inlined.10" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.10" + end + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $entries + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28u8%29=>u8>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28u8%29=>u8>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/object/Object#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/rt/__newArray (param $length i32) (param $alignLog2 i32) (param $id i32) (param $data i32) (result i32) + (local $bufferSize i32) + (local $buffer i32) + (local $array i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + local.get $alignLog2 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + local.get $data + call $~lib/rt/__newBuffer + local.tee $buffer + i32.store + i32.const 16 + local.get $id + call $~lib/rt/itcms/__new + local.set $array + local.get $array + local.get $buffer + i32.store + local.get $array + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + local.get $array + local.get $buffer + i32.store offset=4 + local.get $array + local.get $bufferSize + i32.store offset=8 + local.get $array + local.get $length + i32.store offset=12 + local.get $array + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 0 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 0 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 23 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/arraybuffer/ArrayBuffer#constructor (param $this i32) (param $length i32) (result i32) + (local $buffer i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.gt_u + if + i32.const 8176 + i32.const 8224 + i32.const 52 + i32.const 43 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $buffer + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/util/number/utoa32 (param $value i32) (param $radix i32) (result i32) + (local $out i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|7 i32) + (local $buffer|8 i32) + (local $num|9 i32) + (local $offset|10 i32) + (local $decimals|11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 14608 + i32.const 14736 + i32.const 350 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i32.eqz + if + i32.const 14800 + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer + local.get $value + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 31 + local.get $value + i32.clz + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|7 + global.get $~lib/memory/__stack_pointer + local.get $decimals|7 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|8 + local.get $value + local.set $num|9 + local.get $decimals|7 + local.set $offset|10 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|8 + local.get $num|9 + i64.extend_i32_u + local.get $offset|10 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + i64.extend_i32_u + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|11 + global.get $~lib/memory/__stack_pointer + local.get $decimals|11 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $value + i64.extend_i32_u + local.get $decimals|11 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $out + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $~lib/util/number/itoa32 (param $value i32) (param $radix i32) (result i32) + (local $sign i32) + (local $out i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|8 i32) + (local $buffer|9 i32) + (local $num|10 i32) + (local $offset|11 i32) + (local $val32 i32) + (local $decimals|13 i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 14608 + i32.const 14736 + i32.const 373 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i32.eqz + if + i32.const 14800 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $value + i32.const 31 + i32.shr_u + i32.const 1 + i32.shl + local.set $sign + local.get $sign + if + i32.const 0 + local.get $value + i32.sub + local.set $value + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer + local.get $value + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 31 + local.get $value + i32.clz + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|8 + global.get $~lib/memory/__stack_pointer + local.get $decimals|8 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|9 + local.get $value + local.set $num|10 + local.get $decimals|8 + local.set $offset|11 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|9 + local.get $num|10 + i64.extend_i32_u + local.get $offset|11 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.set $val32 + local.get $val32 + i64.extend_i32_u + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|13 + global.get $~lib/memory/__stack_pointer + local.get $decimals|13 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.get $val32 + i64.extend_i32_u + local.get $decimals|13 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $sign + if + local.get $out + i32.const 45 + i32.store16 + end + local.get $out + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 2 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 32 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 3 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 3 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 14 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 2 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 35 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/util/number/utoa64 (param $value i64) (param $radix i32) (result i32) + (local $out i32) + (local $val32 i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|8 i32) + (local $buffer|9 i32) + (local $num|10 i64) + (local $offset|11 i32) + (local $decimals|12 i32) + (local $buffer|13 i32) + (local $num|14 i64) + (local $offset|15 i32) + (local $decimals|16 i32) + (local $17 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 14608 + i32.const 14736 + i32.const 401 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i64.const 0 + i64.ne + i32.eqz + if + i32.const 14800 + local.set $17 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $17 + return + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + call $~lib/util/number/decimalCount64High + local.set $decimals|8 + global.get $~lib/memory/__stack_pointer + local.get $decimals|8 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|9 + local.get $value + local.set $num|10 + local.get $decimals|8 + local.set $offset|11 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|9 + local.get $num|10 + local.get $offset|11 + call $~lib/util/number/utoa64_dec_lut + end + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 63 + local.get $value + i64.clz + i32.wrap_i64 + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|12 + global.get $~lib/memory/__stack_pointer + local.get $decimals|12 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|13 + local.get $value + local.set $num|14 + local.get $decimals|12 + local.set $offset|15 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|13 + local.get $num|14 + local.get $offset|15 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|16 + global.get $~lib/memory/__stack_pointer + local.get $decimals|16 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $value + local.get $decimals|16 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $out + local.set $17 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $17 + return + ) + (func $~lib/util/number/itoa64 (param $value i64) (param $radix i32) (result i32) + (local $sign i32) + (local $out i32) + (local $val32 i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|9 i32) + (local $buffer|10 i32) + (local $num|11 i64) + (local $offset|12 i32) + (local $decimals|13 i32) + (local $buffer|14 i32) + (local $num|15 i64) + (local $offset|16 i32) + (local $decimals|17 i32) + (local $18 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 14608 + i32.const 14736 + i32.const 431 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i64.const 0 + i64.ne + i32.eqz + if + i32.const 14800 + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + end + local.get $value + i64.const 63 + i64.shr_u + i32.wrap_i64 + i32.const 1 + i32.shl + local.set $sign + local.get $sign + if + i64.const 0 + local.get $value + i64.sub + local.set $value + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + call $~lib/util/number/decimalCount64High + local.set $decimals|9 + global.get $~lib/memory/__stack_pointer + local.get $decimals|9 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|10 + local.get $value + local.set $num|11 + local.get $decimals|9 + local.set $offset|12 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|10 + local.get $num|11 + local.get $offset|12 + call $~lib/util/number/utoa64_dec_lut + end + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 63 + local.get $value + i64.clz + i32.wrap_i64 + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|13 + global.get $~lib/memory/__stack_pointer + local.get $decimals|13 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|14 + local.get $value + local.set $num|15 + local.get $decimals|13 + local.set $offset|16 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|14 + local.get $num|15 + local.get $offset|16 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|17 + global.get $~lib/memory/__stack_pointer + local.get $decimals|17 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.get $value + local.get $decimals|17 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $sign + if + local.get $out + i32.const 45 + i32.store16 + end + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 0 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 0 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 58 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $export:assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $assembly/index/disassemble + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $export:assembly/index/runProgram (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + local.get $2 + call $assembly/index/runProgram + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $export:assembly/api-generic/runVm@varargs (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $assembly/api-generic/runVm@varargs + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $export:assembly/api-generic/getAssembly (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/api-generic/getAssembly + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/program-build/wrapAsProgram + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $export:assembly/api/resetGeneric (param $0 i32) (param $1 i32) (param $2 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + local.get $2 + call $assembly/api/resetGeneric + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $0 + local.get $1 + local.get $2 + local.get $3 + local.get $4 + call $assembly/api/resetGenericWithMemory + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api/setRegisters (param $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/api/setRegisters + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api/setMemory (param $0 i32) (param $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $0 + local.get $1 + call $assembly/api/setMemory + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) +) diff --git a/dist/release.d.ts b/dist/release.d.ts new file mode 100644 index 0000000..97c330c --- /dev/null +++ b/dist/release.d.ts @@ -0,0 +1,182 @@ +/** Exported memory */ +export declare const memory: WebAssembly.Memory; +/** assembly/index/InputKind */ +export declare enum InputKind { + /** @type `i32` */ + Generic, + /** @type `i32` */ + SPI, +} +/** assembly/index/HasMetadata */ +export declare enum HasMetadata { + /** @type `i32` */ + Yes, + /** @type `i32` */ + No, +} +/** + * assembly/index/disassemble + * @param input `~lib/array/Array` + * @param kind `i32` + * @param withMetadata `i32` + * @returns `~lib/string/String` + */ +export declare function disassemble(input: Array, kind: number, withMetadata: number): string; +/** + * assembly/index/runProgram + * @param input `~lib/array/Array` + * @param registers `~lib/array/Array` + * @param kind `i32` + * @returns `assembly/api-generic/VmOutput` + */ +export declare function runProgram(input: Array, registers: Array, kind: number): __Record44; +/** + * assembly/api-generic/runVm + * @param input `assembly/api-generic/VmInput` + * @param logs `bool` + * @param useSbrkGas `bool` + * @returns `assembly/api-generic/VmOutput` + */ +export declare function runVm(input: __Record47, logs?: boolean, useSbrkGas?: boolean): __Record44; +/** + * assembly/api-generic/getAssembly + * @param p `assembly/program/Program` + * @returns `~lib/string/String` + */ +export declare function getAssembly(p: __Internref30): string; +/** + * assembly/program-build/wrapAsProgram + * @param bytecode `~lib/typedarray/Uint8Array` + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array; +/** + * assembly/api/resetGeneric + * @param program `~lib/array/Array` + * @param flatRegisters `~lib/array/Array` + * @param initialGas `i64` + */ +export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint): void; +/** + * assembly/api/resetGenericWithMemory + * @param program `~lib/array/Array` + * @param flatRegisters `~lib/array/Array` + * @param pageMap `~lib/typedarray/Uint8Array` + * @param chunks `~lib/typedarray/Uint8Array` + * @param initialGas `i64` + */ +export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint): void; +/** + * assembly/api/nextStep + * @returns `bool` + */ +export declare function nextStep(): boolean; +/** + * assembly/api/nSteps + * @param steps `u32` + * @returns `bool` + */ +export declare function nSteps(steps: number): boolean; +/** + * assembly/api/getProgramCounter + * @returns `u32` + */ +export declare function getProgramCounter(): number; +/** + * assembly/api/setNextProgramCounter + * @param pc `u32` + */ +export declare function setNextProgramCounter(pc: number): void; +/** + * assembly/api/getStatus + * @returns `u8` + */ +export declare function getStatus(): number; +/** + * assembly/api/getExitArg + * @returns `u32` + */ +export declare function getExitArg(): number; +/** + * assembly/api/getGasLeft + * @returns `i64` + */ +export declare function getGasLeft(): bigint; +/** + * assembly/api/setGasLeft + * @param gas `i64` + */ +export declare function setGasLeft(gas: bigint): void; +/** + * assembly/api/getRegisters + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function getRegisters(): Uint8Array; +/** + * assembly/api/setRegisters + * @param flatRegisters `~lib/array/Array` + */ +export declare function setRegisters(flatRegisters: Array): void; +/** + * assembly/api/getPageDump + * @param index `u32` + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function getPageDump(index: number): Uint8Array; +/** + * assembly/api/setMemory + * @param address `u32` + * @param data `~lib/typedarray/Uint8Array` + */ +export declare function setMemory(address: number, data: Uint8Array): void; +/** assembly/api-generic/InitialChunk */ +declare interface __Record45 { + /** @type `u32` */ + address: number | TOmittable; + /** @type `~lib/array/Array` */ + data: Array; +} +/** assembly/api-generic/VmOutput */ +declare interface __Record44 { + /** @type `i32` */ + status: number | TOmittable; + /** @type `~lib/array/Array` */ + registers: Array; + /** @type `u32` */ + pc: number | TOmittable; + /** @type `~lib/array/Array` */ + memory: Array<__Record45>; + /** @type `i64` */ + gas: bigint | TOmittable; + /** @type `u32` */ + exitCode: number | TOmittable; +} +/** assembly/api-generic/InitialPage */ +declare interface __Record48 { + /** @type `u32` */ + address: number | TOmittable; + /** @type `u32` */ + length: number | TOmittable; + /** @type `i32` */ + access: number | TOmittable; +} +/** assembly/api-generic/VmInput */ +declare interface __Record47 { + /** @type `~lib/array/Array` */ + registers: Array; + /** @type `u32` */ + pc: number | TOmittable; + /** @type `i64` */ + gas: bigint | TOmittable; + /** @type `~lib/array/Array` */ + program: Array; + /** @type `~lib/array/Array` */ + pageMap: Array<__Record48>; + /** @type `~lib/array/Array` */ + memory: Array<__Record45>; +} +/** assembly/program/Program */ +declare class __Internref30 extends Number { + private __nominal30: symbol; + private __nominal0: symbol; +} diff --git a/dist/release.js b/dist/release.js new file mode 100644 index 0000000..f4db6ff --- /dev/null +++ b/dist/release.js @@ -0,0 +1,372 @@ +async function instantiate(module, imports = {}) { + const adaptedImports = { + env: Object.setPrototypeOf({ + abort(message, fileName, lineNumber, columnNumber) { + // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void + message = __liftString(message >>> 0); + fileName = __liftString(fileName >>> 0); + lineNumber = lineNumber >>> 0; + columnNumber = columnNumber >>> 0; + (() => { + // @external.js + throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); + })(); + }, + "console.log"(text) { + // ~lib/bindings/dom/console.log(~lib/string/String) => void + text = __liftString(text >>> 0); + console.log(text); + }, + }, Object.assign(Object.create(globalThis), imports.env || {})), + }; + const { exports } = await WebAssembly.instantiate(module, adaptedImports); + const memory = exports.memory || imports.env.memory; + const adaptedExports = Object.setPrototypeOf({ + InputKind: (values => ( + // assembly/index/InputKind + values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", + values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", + values + ))({}), + HasMetadata: (values => ( + // assembly/index/HasMetadata + values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", + values[values.No = exports["HasMetadata.No"].valueOf()] = "No", + values + ))({}), + disassemble(input, kind, withMetadata) { + // assembly/index/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String + input = __lowerArray(__setU8, 27, 0, input) || __notnull(); + return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); + }, + runProgram(input, registers, kind) { + // assembly/index/runProgram(~lib/array/Array, ~lib/array/Array, i32) => assembly/api-generic/VmOutput + input = __retain(__lowerArray(__setU8, 27, 0, input) || __notnull()); + registers = __lowerArray(__setU64, 43, 3, registers) || __notnull(); + try { + return __liftRecord44(exports.runProgram(input, registers, kind) >>> 0); + } finally { + __release(input); + } + }, + runVm(input, logs, useSbrkGas) { + // assembly/api-generic/runVm(assembly/api-generic/VmInput, bool?, bool?) => assembly/api-generic/VmOutput + input = __lowerRecord47(input) || __notnull(); + logs = logs ? 1 : 0; + useSbrkGas = useSbrkGas ? 1 : 0; + exports.__setArgumentsLength(arguments.length); + return __liftRecord44(exports.runVm(input, logs, useSbrkGas) >>> 0); + }, + getAssembly(p) { + // assembly/api-generic/getAssembly(assembly/program/Program) => ~lib/string/String + p = __lowerInternref(p) || __notnull(); + return __liftString(exports.getAssembly(p) >>> 0); + }, + wrapAsProgram(bytecode) { + // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array + bytecode = __lowerTypedArray(Uint8Array, 5, 0, bytecode) || __notnull(); + return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0); + }, + resetGeneric(program, flatRegisters, initialGas) { + // assembly/api/resetGeneric(~lib/array/Array, ~lib/array/Array, i64) => void + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); + initialGas = initialGas || 0n; + try { + exports.resetGeneric(program, flatRegisters, initialGas); + } finally { + __release(program); + } + }, + resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas) { + // assembly/api/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64) => void + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + flatRegisters = __retain(__lowerArray(__setU8, 27, 0, flatRegisters) || __notnull()); + pageMap = __retain(__lowerTypedArray(Uint8Array, 5, 0, pageMap) || __notnull()); + chunks = __lowerTypedArray(Uint8Array, 5, 0, chunks) || __notnull(); + initialGas = initialGas || 0n; + try { + exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas); + } finally { + __release(program); + __release(flatRegisters); + __release(pageMap); + } + }, + nextStep() { + // assembly/api/nextStep() => bool + return exports.nextStep() != 0; + }, + nSteps(steps) { + // assembly/api/nSteps(u32) => bool + return exports.nSteps(steps) != 0; + }, + getProgramCounter() { + // assembly/api/getProgramCounter() => u32 + return exports.getProgramCounter() >>> 0; + }, + getExitArg() { + // assembly/api/getExitArg() => u32 + return exports.getExitArg() >>> 0; + }, + setGasLeft(gas) { + // assembly/api/setGasLeft(i64) => void + gas = gas || 0n; + exports.setGasLeft(gas); + }, + getRegisters() { + // assembly/api/getRegisters() => ~lib/typedarray/Uint8Array + return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); + }, + setRegisters(flatRegisters) { + // assembly/api/setRegisters(~lib/array/Array) => void + flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); + exports.setRegisters(flatRegisters); + }, + getPageDump(index) { + // assembly/api/getPageDump(u32) => ~lib/typedarray/Uint8Array + return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); + }, + setMemory(address, data) { + // assembly/api/setMemory(u32, ~lib/typedarray/Uint8Array) => void + data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); + exports.setMemory(address, data); + }, + }, exports); + function __liftRecord45(pointer) { + // assembly/api-generic/InitialChunk + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + address: __getU32(pointer + 0), + data: __liftArray(__getU8, 0, __getU32(pointer + 4)), + }; + } + function __liftRecord44(pointer) { + // assembly/api-generic/VmOutput + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + status: __getI32(pointer + 0), + registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), + pc: __getU32(pointer + 8), + memory: __liftArray(pointer => __liftRecord45(__getU32(pointer)), 2, __getU32(pointer + 12)), + gas: __getI64(pointer + 16), + exitCode: __getU32(pointer + 24), + }; + } + function __lowerRecord48(value) { + // assembly/api-generic/InitialPage + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(12, 48)); + __setU32(pointer + 0, value.address); + __setU32(pointer + 4, value.length); + __setU32(pointer + 8, value.access); + exports.__unpin(pointer); + return pointer; + } + function __lowerRecord45(value) { + // assembly/api-generic/InitialChunk + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(8, 45)); + __setU32(pointer + 0, value.address); + __setU32(pointer + 4, __lowerArray(__setU8, 27, 0, value.data) || __notnull()); + exports.__unpin(pointer); + return pointer; + } + function __lowerRecord47(value) { + // assembly/api-generic/VmInput + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(28, 47)); + __setU32(pointer + 0, __lowerArray(__setU64, 43, 3, value.registers) || __notnull()); + __setU32(pointer + 4, value.pc); + __setU64(pointer + 8, value.gas || 0n); + __setU32(pointer + 16, __lowerArray(__setU8, 27, 0, value.program) || __notnull()); + __setU32(pointer + 20, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, value.pageMap) || __notnull()); + __setU32(pointer + 24, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord45(value) || __notnull()); }, 46, 2, value.memory) || __notnull()); + exports.__unpin(pointer); + return pointer; + } + function __liftString(pointer) { + if (!pointer) return null; + const + end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, + memoryU16 = new Uint16Array(memory.buffer); + let + start = pointer >>> 1, + string = ""; + while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); + return string + String.fromCharCode(...memoryU16.subarray(start, end)); + } + function __liftArray(liftElement, align, pointer) { + if (!pointer) return null; + const + dataStart = __getU32(pointer + 4), + length = __dataview.getUint32(pointer + 12, true), + values = new Array(length); + for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0)); + return values; + } + function __lowerArray(lowerElement, id, align, values) { + if (values == null) return 0; + const + length = values.length, + buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, + header = exports.__pin(exports.__new(16, id)) >>> 0; + __setU32(header + 0, buffer); + __dataview.setUint32(header + 4, buffer, true); + __dataview.setUint32(header + 8, length << align, true); + __dataview.setUint32(header + 12, length, true); + for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]); + exports.__unpin(buffer); + exports.__unpin(header); + return header; + } + function __liftTypedArray(constructor, pointer) { + if (!pointer) return null; + return new constructor( + memory.buffer, + __getU32(pointer + 4), + __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT + ).slice(); + } + function __lowerTypedArray(constructor, id, align, values) { + if (values == null) return 0; + const + length = values.length, + buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, + header = exports.__new(12, id) >>> 0; + __setU32(header + 0, buffer); + __dataview.setUint32(header + 4, buffer, true); + __dataview.setUint32(header + 8, length << align, true); + new constructor(memory.buffer, buffer, length).set(values); + exports.__unpin(buffer); + return header; + } + class Internref extends Number {} + function __lowerInternref(value) { + if (value == null) return 0; + if (value instanceof Internref) return value.valueOf(); + throw TypeError("internref expected"); + } + const refcounts = new Map(); + function __retain(pointer) { + if (pointer) { + const refcount = refcounts.get(pointer); + if (refcount) refcounts.set(pointer, refcount + 1); + else refcounts.set(exports.__pin(pointer), 1); + } + return pointer; + } + function __release(pointer) { + if (pointer) { + const refcount = refcounts.get(pointer); + if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer); + else if (refcount) refcounts.set(pointer, refcount - 1); + else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`); + } + } + function __notnull() { + throw TypeError("value must not be null"); + } + let __dataview = new DataView(memory.buffer); + function __setU8(pointer, value) { + try { + __dataview.setUint8(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setUint8(pointer, value, true); + } + } + function __setU32(pointer, value) { + try { + __dataview.setUint32(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setUint32(pointer, value, true); + } + } + function __setU64(pointer, value) { + try { + __dataview.setBigUint64(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setBigUint64(pointer, value, true); + } + } + function __getU8(pointer) { + try { + return __dataview.getUint8(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getUint8(pointer, true); + } + } + function __getI32(pointer) { + try { + return __dataview.getInt32(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getInt32(pointer, true); + } + } + function __getU32(pointer) { + try { + return __dataview.getUint32(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getUint32(pointer, true); + } + } + function __getI64(pointer) { + try { + return __dataview.getBigInt64(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getBigInt64(pointer, true); + } + } + function __getU64(pointer) { + try { + return __dataview.getBigUint64(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getBigUint64(pointer, true); + } + } + return adaptedExports; +} +export const { + memory, + InputKind, + HasMetadata, + disassemble, + runProgram, + runVm, + getAssembly, + wrapAsProgram, + resetGeneric, + resetGenericWithMemory, + nextStep, + nSteps, + getProgramCounter, + setNextProgramCounter, + getStatus, + getExitArg, + getGasLeft, + setGasLeft, + getRegisters, + setRegisters, + getPageDump, + setMemory, +} = await (async url => instantiate( + await (async () => { + const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); + if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } + else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } + })(), { + } +))(new URL("release.wasm", import.meta.url)); diff --git a/dist/release.wasm b/dist/release.wasm new file mode 100644 index 0000000000000000000000000000000000000000..5dbaeb3b3175e196f275a6e9299e4947e9fcf099 GIT binary patch literal 93361 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 I=Ge^t0d}!nbN~PV literal 0 HcmV?d00001 diff --git a/dist/release.wasm.map b/dist/release.wasm.map new file mode 100644 index 0000000..16de3d7 --- /dev/null +++ b/dist/release.wasm.map @@ -0,0 +1 @@ +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/api.ts","assembly/index.ts","~lib/number.ts","~lib/string.ts","~lib/memory.ts","assembly/api-generic.ts","assembly/gas.ts","assembly/program-build.ts","~lib/dataview.ts","~lib/function.ts"],"names":[],"mappings":"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zCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAGA,EAAO,E,EACY,E,GAAjB,EACmB,EAAb,CAAF,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D,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTwHO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDShIM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/EgB,CAAlD,EAAK,EAAL,EU+EoB,EAAzB,G,EAE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CAAlD,EAAK,EAAL,EUkJ0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZjLO,E,6Da9CP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KX6EJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EW7EI,G,EX6EkB,CAAlD,EAAK,EAAL,EW7EkB,EAAzB,Eb8CO,E,sDaxCH,E,KAAc,E,KXuEiB,E,EWvEjB,G,EXuEuC,CAAlD,EAAK,EAAL,EWvEH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EXiE1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GWjEb,GbuCK,E,sDahCH,E,KAAc,E,KX+DiB,E,EW/DjB,G,EX+DuC,CAAlD,EAAK,EAAL,EW/DH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EXyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GWzDb,Gb+BK,E,6DaxBH,E,KAAc,E,KXuDiB,E,EWvDjB,G,EXuDuC,CAAlD,EAAK,EAAL,EWvDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KXsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EWtDM,G,EXsDgB,CAAlD,EAAK,EAAL,EWtDoB,EAAzB,GbuBK,E,6DahBH,E,KAAc,E,KX+CiB,E,EW/CjB,G,EX+CuC,CAAlD,EAAK,EAAL,EW/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KX8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EW9CM,G,EX8CgB,CAAlD,EAAK,EAAL,EW9CoB,EAAzB,GbeK,E,6Dc9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZ6EL,E,EY7EK,G,EZ6EiB,CAAlD,EAAK,EAAL,EY7EwB,E,IAAiC,EZwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EY7EwB,E,EZwEhB,GYvBN,CAjDT,Ed8CO,E,6DcxCP,E,YAAS,G,IAAoC,E,KZkE9B,G,IYlEuC,E,KAAS,E,KZuE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EYvE4B,G,EZuEN,CAAlD,EAAK,EAAL,EYvE+C,EA2C7C,CA3CT,EdwCO,E,6DclCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZiE1B,E,EYjE0B,G,EZiEJ,CAAlD,EAAK,EAAL,E,EYjEyC,C,IAA4B,EAyCtD,G,EZwBa,E,EAAsB,CAAlD,EAAK,EAAL,EYjEyC,E,EAyC1B,GAAb,CZmBF,CY5DP,EdkCO,E,6Dc5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,KZ2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EYxBY,E,EZwBgB,E,EY3DuC,G,EZ2DjB,CAAlD,EAAK,EAAL,E,EY3DsD,CAmCpD,CZmBF,CYtDP,Ed4BO,E,6DctBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZqDL,E,EYrDK,G,EZqDiB,CAAlD,EAAK,EAAL,EYrDwB,E,IAAmB,E,KAAS,E,KZqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EYrDwB,E,EZqDI,E,EYrDwB,G,EZqDF,CAAlD,EAAK,EAAL,EYrD2C,EAiCzC,CAjCT,EdsBO,E,6DchBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZ+C1B,E,EY/C0B,G,EZ+CJ,CAAlD,EAAK,EAAL,E,EY/CyC,C,IAA4B,E,KAAS,E,KZ+ClD,E,EAAsB,CAAlD,EAAK,EAAL,EY/CyC,E,EZ+Cb,E,EY/CkD,G,EZ+C5B,CAAlD,EAAK,EAAL,E,EY/CiE,CA+B/D,CZWF,CY1CP,EdgBO,E,6DcVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZyCL,E,EYzCK,G,EZyCiB,CAAlD,EAAK,EAAL,EYzCwB,E,IAAmB,E,KAAS,E,KZyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EYzCwB,E,EZyCI,E,EYzCwB,G,EZyCF,CAAlD,EAAK,EAAL,EYzC2C,EAazC,CAbT,EdUO,E,6DcJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZmC1B,E,EYnC0B,G,EZmCJ,CAAlD,EAAK,EAAL,E,EYnCyC,C,IAA4B,E,KAAS,E,KZmClD,E,EAAsB,CAAlD,EAAK,EAAL,EYnCyC,E,EZmCb,E,EYnCkD,G,EZmC5B,CAAlD,EAAK,EAAL,E,EYnCiE,CAW/D,CZmBF,CY9BP,EdIO,E,sDe9CM,E,Yb6EsB,E,Ea7ER,G,Eb6E8B,CAAlD,EAAK,EAAL,Ea7EM,E,EAA2C,EbwEzC,G,EAAA,GaxEF,CAAb,E,EACA,E,KAAc,E,Kb4EqB,E,Ea5ErB,G,Eb4E2C,CAAlD,EAAK,EAAL,Ea5EkB,GAAzB,Ef6CO,E,sDevCU,E,YbsEkB,E,EatEJ,G,EbsE0B,CAAlD,EAAK,EAAL,EatEM,E,EAA4C,EbiE1C,G,EAAA,GajEF,CAAb,E,EACA,E,KAAc,E,KbqEqB,E,EarErB,G,EbqE2C,CAAlD,EAAK,EAAL,EarEkB,GAAzB,EfsCO,E,sDehCM,E,Yb+DsB,E,Ea/DR,G,Eb+D8B,CAAlD,EAAK,EAAL,Ea/DM,E,EAA2C,Eb0DzC,G,EAAA,Ga1DF,CAAb,E,EACA,E,KAAc,E,Kb8DqB,E,Ea9DrB,G,Eb8D2C,CAAlD,EAAK,EAAL,Ea9DkB,GAAzB,Ef+BO,E,sDezBU,E,YbwDkB,E,EaxDJ,G,EbwD0B,CAAlD,EAAK,EAAL,EaxDM,E,EAA4C,EbmD1C,G,EAAA,GanDF,CAAb,E,EACA,E,KAAc,E,KbuDqB,E,EavDrB,G,EbuD2C,CAAlD,EAAK,EAAL,EavDkB,GAAzB,EfwBO,E,6DelBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbiDJ,E,EajDI,G,EbiDkB,CAAlD,EAAK,EAAL,EajDkB,E,IAAyB,E,KAAc,E,KbiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EajD6B,G,EbiDP,CAAlD,EAAK,EAAL,EajD2C,EAAzB,IAAzB,EfkBO,E,6DeZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kb2CR,E,Ea3CQ,G,Eb2Cc,CAAlD,EAAK,EAAL,Ea3CkB,E,IAAkC,E,KAAc,E,Kb2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea3CsC,G,Eb2ChB,CAAlD,EAAK,EAAL,Ea3CgD,EAA9B,IAAzB,EfYO,E,wDgB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdyEG,E,EczEH,G,EdyEyB,CAAlD,EAAK,EAAL,E,EczEO,CAAd,E,EACA,E,KAAc,E,KdwEqB,E,EcxErB,G,EdwE2C,CAAlD,EAAK,EAAL,EcxEgC,EAAS,EAAT,CdmEhC,CcnEP,EhByCO,E,wDgBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdiEG,E,EcjEH,G,EdiEyB,CAAlD,EAAK,EAAL,E,EcjEO,CAAd,E,EACA,E,KAAc,E,KdgEqB,E,EchErB,G,EdgE2C,CAAlD,EAAK,EAAL,EchEgC,EAAU,EAAV,Cd2DhC,Cc3DP,EhBiCO,E,sDgB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KdyDX,E,EczDW,G,EdyDW,CAAlD,EAAK,EAAL,E,EczDqB,CAA5B,E,EACA,E,KAAc,E,KdwDqB,E,EcxDrB,G,EdwD2C,CAAlD,EAAK,EAAL,EcxDkB,E,EAAS,CAAT,CAAzB,EhByBO,E,sDgBnBW,E,KAAc,E,KdkDG,E,EclDH,G,EdkDyB,CAAlD,EAAK,EAAL,EclDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EdiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KcjD0C,EAAV,Cd4ChC,Cc5CP,EhBkBO,E,sDgBZW,E,KAAc,E,Kd2CG,E,Ec3CH,G,Ed2CyB,CAAlD,EAAK,EAAL,Ec3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,Ed0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,Kc1C2C,EAAX,CdqChC,CcrCP,EhBWO,E,sDgBLW,E,YdoCiB,E,EcpCH,G,EdoCyB,CAAlD,EAAK,EAAL,EcpCW,E,GAAJ,CAAd,E,EAC0B,E,Kd8BX,Gc9Bf,E,EACA,E,KAAc,E,KdkCqB,E,EclCrB,G,EdkC2C,CAAlD,EAAK,EAAL,EclCoC,E,EAAO,C,CAAX,CAAvC,EhBGO,E,6DgBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kd2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ec3BI,G,Ed2BkB,CAAlD,EAAK,EAAL,Ec3BkB,E,EAA0B,CAA1B,CAAzB,EhBJO,E,6DgBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcpBI,G,EdoBkB,CAAlD,EAAK,EAAL,EcpBkB,E,EAA2B,CAA3B,CAAzB,EhBXO,E,sDgBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdaG,E,EcbH,G,EdayB,CAAlD,EAAK,EAAL,EcbO,EAAd,E,EACA,E,KAAc,E,KdYqB,E,EcZrB,G,EdY2C,CAAlD,EAAK,EAAL,EcZkB,E,EAAS,CAAT,CAAzB,EhBnBO,E,sDgByBW,E,KAAc,E,KdMG,E,EcNH,G,EdMyB,CAAlD,EAAK,EAAL,EcNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EdAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EcAmC,CAAzB,CAAzB,EhB1BO,E,sDgBgCW,E,KAAc,E,KdDG,E,EcCH,G,EdDyB,CAAlD,EAAK,EAAL,EcCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EdPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EcOoC,CAA1B,CAAzB,EhBjCO,E,sDgBuCW,E,YdRiB,E,EcQH,G,EdRyB,CAAlD,EAAK,EAAL,EcQW,E,GAAJ,CAAd,E,EAC4B,E,Kddb,Gccf,E,EACA,E,KAAc,E,KdVqB,E,EcUrB,G,EdV2C,CAAlD,EAAK,EAAL,EcUoC,E,EAAS,C,CAAb,CAAvC,EhBzCO,E,wDgB+CW,E,KAAc,E,KdhBG,E,EcgBH,G,EdhByB,CAAlD,EAAK,EAAL,EcgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KdjBG,E,EciBH,G,EdjByB,CAAlD,EAAK,EAAL,E,EciBO,CAAd,E,EACA,E,KAAc,E,KdlBqB,E,EckBrB,G,EdlB2C,CAAlD,EAAK,EAAL,EckBgC,EAAS,EAAT,CdvBhC,CcuBP,EhBjDO,E,wDgBuDW,E,KAAc,E,KdxBG,E,EcwBH,G,EdxByB,CAAlD,EAAK,EAAL,EcwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KdzBG,E,EcyBH,G,EdzByB,CAAlD,EAAK,EAAL,E,EcyBO,CAAd,E,EACA,E,KAAc,E,Kd1BqB,E,Ec0BrB,G,Ed1B2C,CAAlD,EAAK,EAAL,Ec0BgC,EAAU,EAAV,Cd/BhC,Cc+BP,EhBzDO,E,sDgB+DW,E,KAAc,E,KdhCG,E,EcgCH,G,EdhCyB,CAAlD,EAAK,EAAL,EcgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KdjCd,E,EciCc,G,EdjCQ,CAAlD,EAAK,EAAL,E,EciCwB,CAA/B,E,EACA,E,KAAc,E,KdlCqB,E,EckCrB,G,EdlC2C,CAAlD,EAAK,EAAL,EckCoC,E,EAAY,C,CAAhB,CAAvC,EhBjEO,E,6DgBuEW,E,KAAc,E,KdxCG,E,EcwCH,G,EdxCyB,CAAlD,EAAK,EAAL,EcwCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdzCJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcyCI,G,EdzCkB,CAAlD,EAAK,EAAL,EcyCkB,E,EAA0B,CAA1B,CAAzB,EhBxEO,E,6DgB8EW,E,KAAc,E,Kd/CG,E,Ec+CH,G,Ed/CyB,CAAlD,EAAK,EAAL,Ec+CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdhDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcgDI,G,EdhDkB,CAAlD,EAAK,EAAL,EcgDkB,E,EAA2B,CAA3B,CAAzB,EhB/EO,E,6DgBqFW,E,KAAc,E,KdtDG,E,EcsDH,G,EdtDyB,CAAlD,EAAK,EAAL,EcsDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,KdvDR,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcuDQ,G,EdvDc,CAAlD,EAAK,EAAL,EcuDkB,E,EAA+B,CAA/B,CAAzB,EhBtFO,E,mDV8HkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cACnD,E,GAAiB,E,KAAjB,CAA+B,EAAzC,G,2DQ6DY,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,E,IAAf,G,EACO,E,kEmB/OO,E,QAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,2DnBiPO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,EAAQ,GAAR,CAAf,G,EACI,E,iBAAA,EAAmB,EAAnB,CAAJ,E,EACE,E,iBAAU,EAAK,E,KAAS,EAAT,CAAf,I,EAEA,E,iBAAW,EAAK,E,KAAS,EAAT,CAAhB,I,EAEK,E,kEmBtPO,E,QAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DnBwPO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,EAAK,EAAI,GAAJ,CAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,EAAK,EAAI,GAAJ,CAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEmBrQO,E,QAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DnBuQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,E,EAAK,C,IAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,E,EAAK,C,IAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEmBpRO,E,QAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EfkDjB,GelDG,G,OACD,E,KAAV,E,+DAKO,E,KAAa,E,YAAa,E,KAAc,E,WfiDnB,E,EejDmB,G,EfiDG,CAAlD,EAAK,EAAL,EejDiC,EAAyB,G,CAA9B,CAArB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAc,E,KAAc,E,Wf2CrB,E,Ee3CqB,G,Ef2CC,CAAlD,EAAK,EAAL,Ee3CmC,EAAyB,I,CAA/B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAY,E,KAAc,E,WfqCnB,E,EerCmB,G,EfqCG,CAAlD,EAAK,EAAL,E,EerC6B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAQ,E,KAAc,E,Wf+Bf,E,Ee/Be,G,Ef+BO,CAAlD,EAAK,EAAL,Ee/B6B,EAAtB,G,OACG,E,KAAV,E,6DAKa,E,YfyBe,E,EezBD,G,EfyBuB,CAAlD,EAAK,EAAL,EezBa,E,EAAuC,EfoB5C,G,EAAA,G,CepBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YfkBe,E,EelBD,G,EfkBuB,CAAlD,EAAK,EAAL,EelBa,E,EAAuC,Efa5C,G,EAAA,G,CebC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YfWe,E,EeXD,G,EfWuB,CAAlD,EAAK,EAAL,EeXa,E,EAAuC,EfM5C,G,EAAA,G,CeNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YfIe,E,EeJD,G,EfIuB,CAAlD,EAAK,EAAL,EeJa,E,EAAuC,EfD5C,G,EAAA,G,CeCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EfFjB,GeEG,G,OACD,E,KAAV,E,+DAKa,E,YfHe,E,EeGD,G,EfHuB,CAAlD,EAAK,EAAL,EeGa,E,EAAuC,EfR5C,G,EAAA,G,CeQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EfJQ,E,EeIoB,G,EfJE,CAAlD,EAAK,EAAL,EeIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YfVe,E,EeUD,G,EfVuB,CAAlD,EAAK,EAAL,EeUa,E,EAAuC,Eff5C,G,EAAA,G,CeeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EfXO,E,EeWsB,G,EfXA,CAAlD,EAAK,EAAL,EeWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YfjBe,E,EeiBD,G,EfjBuB,CAAlD,EAAK,EAAL,EeiBa,E,EAAuC,EftB5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OACK,E,QAAf,E,EACgB,EAAI,EAAJ,C,EACU,EAA2B,EAAY,EAAZ,CAA3B,CAAR,G,IAAkE,E,SAAlE,EAA+D,E,EAAlE,E,GAAA,G,KACJ,EAAY,EAAY,EAAZ,CAAZ,CAAuC,EAAhD,GAES,EAAwB,EAA2B,EADxC,EAHK,E,GAAF,E,WAOlB,E,8CRsHG,E,KAOmC,G,EANnC,EAMwC,G,EAAA,G,aAArB,G,wD2B7JI,E,KAAN,E,EAAY,EAA5B,G,KACT,GAAJ,E,OACS,EAAP,E,yEAfO,E,YACA,E,YACA,E,YACA,E,UACO,E,sCAehB,E,KAAmB,E,gCAEX,E,mBAOJ,E,KAA2B,E,OpB3NhB,G,QoBkOX,E,KAAa,E,KAAc,E,OpB7NI,E,EoB6NJ,G,EpB7N0B,CAAlD,EAAK,EAAL,EoB6NU,E,QAIb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,KACb,E,KAAkB,E,KAAJ,GAAe,EAAf,C,IAAyB,EAAJ,G,EAArB,E,EAAqB,GAAtB,C,QAab,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAAa,E,KAAc,E,OpBhPI,E,EoBgPJ,G,EpBhP0B,CAAlD,EAAK,EAAL,EoBgPU,E,QAab,E,KAAa,E,KAAc,E,OpB7PI,E,EoB6PJ,G,EpB7P0B,CAAlD,EAAK,EAAL,EoB6PU,E,KACb,E,KAAa,E,KAAc,E,OpB9PI,E,EoB8PJ,G,EpB9P0B,CAAlD,EAAK,EAAL,EoB8PU,E,KACb,E,KAA2B,E,OpBpQhB,G,KoBqQX,E,KAA2B,E,OpBrQhB,G,QoBwQX,E,KAAa,E,KAAc,E,OpBnQI,E,EoBmQJ,G,EpBnQ0B,CAAlD,EAAK,EAAL,EoBmQU,E,KACb,E,KAAa,E,KAAc,E,OpBpQI,E,EoBoQJ,G,EpBpQ0B,CAAlD,EAAK,EAAL,EoBoQU,E,KACb,E,KAAa,E,KAAc,E,OpBrQI,E,EoBqQJ,G,EpBrQ0B,CAAlD,EAAK,EAAL,EoBqQU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBxNhB,G,QoB4NX,E,KAA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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/0a78010a7801?v=0.6.4 **/\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT = 12;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/24ee0024ee00?v=0.6.4 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const pageIdx = u32(currentAddress >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n const relAddress = currentAddress % PAGE_SIZE;\n const page = this.pages.get(pageIdx);\n const spaceInPage = PAGE_SIZE - relAddress;\n\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** https://graypaper.fluffylabs.dev/#/9a08063/2cc5022cc502?v=0.6.6 */\nexport function decodeSpi(data: Uint8Array): Program {\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const _heapPages = decoder.u16();\n const _stackSize = decoder.u24();\n\n const _roMem = decoder.bytes(roLength);\n const _rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n return deblob(code);\n}\n\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { RUN } from \"./instructions-exe\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, JumpTable, Program, ProgramCounter, decodeArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { InitialChunk, InitialPage, buildMemory } from \"./api-generic\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { VmInput, VmOutput, getAssembly, runVm } from \"./api-generic\";\nimport { deblob, decodeSpi, extractCodeAndMetadata, liftBytes } from \"./program\";\n\nexport * from \"./api\";\nexport { runVm, getAssembly } from \"./api-generic\";\nexport { wrapAsProgram } from \"./program-build\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n let program = liftBytes(input);\n let output = \"\";\n\n if (withMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(program);\n program = data.code;\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += data.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n if (kind === InputKind.Generic) {\n const p = deblob(program);\n return output + getAssembly(p);\n }\n\n if (kind === InputKind.SPI) {\n const p = decodeSpi(program);\n return output + getAssembly(p);\n }\n\n return `Unknown kind: ${kind}`;\n}\n\nexport function runProgram(input: u8[], registers: u64[], kind: InputKind): VmOutput {\n if (kind === InputKind.Generic) {\n const vmInput = new VmInput();\n vmInput.registers = registers;\n vmInput.gas = 10_000;\n vmInput.program = input;\n\n const output = runVm(vmInput, true);\n console.log(`Finished with status: ${output.status}`);\n return output;\n }\n\n if (kind === InputKind.SPI) {\n throw new Error(\"SPI running not supported yet\");\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { Program, deblob, decodeArguments, liftBytes, resolveArguments } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n registers: u64[] = new Array(NO_OF_REGISTERS).fill(0);\n pc: u32 = 0;\n gas: i64 = 0;\n program: u8[] = [];\n pageMap: InitialPage[] = [];\n memory: InitialChunk[] = [];\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const p = deblob(liftBytes(input.program));\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < registers.length; r++) {\n registers[r] = input.registers[r];\n }\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, input.pageMap, input.memory);\n\n const int = new Interpreter(p, registers, memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = p.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n return this.gas < 0;\n }\n}\n","import { Arguments, REQUIRED_BYTES, nibbles } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/dist/release.wat b/dist/release.wat new file mode 100644 index 0000000..4de45a6 --- /dev/null +++ b/dist/release.wat @@ -0,0 +1,36780 @@ +(module + (type $0 (func (param i32 i32 i32) (result i32))) + (type $1 (func (param i32 i32) (result i32))) + (type $2 (func (param i32) (result i32))) + (type $3 (func (result i32))) + (type $4 (func (param i32))) + (type $5 (func (param i32 i32))) + (type $6 (func (param i32 i32 i32))) + (type $7 (func (param i32 i32 i32 i32) (result i32))) + (type $8 (func)) + (type $9 (func (param i32 i32 i32 i32))) + (type $10 (func (param i32 i32 i64))) + (type $11 (func (param i32 i64) (result i32))) + (type $12 (func (param i64 i32 i32) (result i32))) + (type $13 (func (param i64) (result i32))) + (type $14 (func (param i32 i32 i32 i32 i64))) + (type $15 (func (param i32 i64 i32 i32))) + (type $16 (func (param i32 i64 i32))) + (type $17 (func (param i32 i64))) + (type $18 (func (param i32) (result i64))) + (type $19 (func (param i32 i32) (result i64))) + (type $20 (func (param i32 i32 i64) (result i32))) + (type $21 (func (result i64))) + (type $22 (func (param i64))) + (type $23 (func (param i64 i32) (result i32))) + (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) + (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) + (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) + (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) + (global $~argumentsLength (mut i32) (i32.const 0)) + (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) + (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) + (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) + (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) + (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) + (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) + (global $assembly/api/interpreter (mut i32) (i32.const 0)) + (global $assembly/index/InputKind.Generic i32 (i32.const 0)) + (global $assembly/index/InputKind.SPI i32 (i32.const 1)) + (global $assembly/index/HasMetadata.Yes i32 (i32.const 0)) + (global $assembly/index/HasMetadata.No i32 (i32.const 1)) + (global $~lib/rt/__rtti_base i32 (i32.const 21056)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 54068)) + (memory $0 1) + (data $0 (i32.const 1036) "L") + (data $0.1 (i32.const 1048) "\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03") + (data $1 (i32.const 1116) ",") + (data $1.1 (i32.const 1128) "\04\00\00\00\10\00\00\00 \04\00\00 \04\00\004\00\00\00\r") + (data $2 (i32.const 1164) "L") + (data $2.1 (i32.const 1176) "\01\00\00\004") + (data $2.2 (i32.const 1192) "\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02") + (data $3 (i32.const 1244) ",") + (data $3.1 (i32.const 1256) "\04\00\00\00\10\00\00\00\a0\04\00\00\a0\04\00\004\00\00\00\r") + (data $4 (i32.const 1292) "<") + (data $4.1 (i32.const 1304) "\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e") + (data $5 (i32.const 1356) "<") + (data $5.1 (i32.const 1368) "\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s") + (data $8 (i32.const 1484) "<") + (data $8.1 (i32.const 1496) "\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e") + (data $9 (i32.const 1548) ",") + (data $9.1 (i32.const 1560) "\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s") + (data $11 (i32.const 1628) "<") + (data $11.1 (i32.const 1640) "\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s") + (data $12 (i32.const 1692) "\1c") + (data $12.1 (i32.const 1704) "\08\00\00\00\08\00\00\00\01") + (data $13 (i32.const 1724) "<") + (data $13.1 (i32.const 1736) "\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s") + (data $14 (i32.const 1788) "\1c") + (data $14.1 (i32.const 1800) "\08\00\00\00\08\00\00\00\02") + (data $15 (i32.const 1820) "\1c") + (data $15.1 (i32.const 1832) "\08\00\00\00\08\00\00\00\03") + (data $16 (i32.const 1852) "\1c") + (data $16.1 (i32.const 1864) "\08\00\00\00\08\00\00\00\04") + (data $17 (i32.const 1884) "\1c") + (data $17.1 (i32.const 1896) "\08\00\00\00\08\00\00\00\05") + (data $18 (i32.const 1916) "\1c") + (data $18.1 (i32.const 1928) "\08\00\00\00\08\00\00\00\06") + (data $19 (i32.const 1948) "\1c") + (data $19.1 (i32.const 1960) "\08\00\00\00\08\00\00\00\07") + (data $20 (i32.const 1980) "\1c") + (data $20.1 (i32.const 1992) "\08\00\00\00\08\00\00\00\08") + (data $21 (i32.const 2012) "\1c") + (data $21.1 (i32.const 2024) "\08\00\00\00\08\00\00\00\t") + (data $22 (i32.const 2044) "\1c") + (data $22.1 (i32.const 2056) "\08\00\00\00\08\00\00\00\n") + (data $23 (i32.const 2076) "\1c") + (data $23.1 (i32.const 2088) "\08\00\00\00\08\00\00\00\0b") + (data $24 (i32.const 2108) "\1c") + (data $24.1 (i32.const 2120) "\08\00\00\00\08\00\00\00\0c") + (data $25 (i32.const 2140) "\1c") + (data $25.1 (i32.const 2152) "\08\00\00\00\08\00\00\00\r") + (data $26 (i32.const 2172) "L") + (data $26.1 (i32.const 2184) "\01\00\00\004\00\00\00\b0\06\00\00\10\07\00\000\07\00\00P\07\00\00p\07\00\00\90\07\00\00\b0\07\00\00\d0\07\00\00\f0\07\00\00\10\08\00\000\08\00\00P\08\00\00p\08") + (data $27 (i32.const 2252) ",") + (data $27.1 (i32.const 2264) "\07\00\00\00\10\00\00\00\90\08\00\00\90\08\00\004\00\00\00\r") + (data $28 (i32.const 2300) ",") + (data $28.1 (i32.const 2312) "\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D") + (data $29 (i32.const 2348) "\1c") + (data $29.1 (i32.const 2360) "\02\00\00\00\08\00\00\00S\00B\00R\00K") + (data $30 (i32.const 2380) "\1c") + (data $30.1 (i32.const 2392) "\02\00\00\00\08\00\00\00T\00R\00A\00P") + (data $31 (i32.const 2412) ",") + (data $31.1 (i32.const 2424) "\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H") + (data $32 (i32.const 2460) "\1c") + (data $32.1 (i32.const 2472) "\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I") + (data $33 (i32.const 2492) ",") + (data $33.1 (i32.const 2504) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004") + (data $34 (i32.const 2540) ",") + (data $34.1 (i32.const 2552) "\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008") + (data $35 (i32.const 2588) ",") + (data $35.1 (i32.const 2600) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006") + (data $36 (i32.const 2636) ",") + (data $36.1 (i32.const 2648) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002") + (data $37 (i32.const 2684) ",") + (data $37.1 (i32.const 2696) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004") + (data $38 (i32.const 2732) "\1c") + (data $38.1 (i32.const 2744) "\02\00\00\00\08\00\00\00J\00U\00M\00P") + (data $39 (i32.const 2764) ",") + (data $39.1 (i32.const 2776) "\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D") + (data $40 (i32.const 2812) ",") + (data $40.1 (i32.const 2824) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M") + (data $41 (i32.const 2860) ",") + (data $41.1 (i32.const 2872) "\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008") + (data $42 (i32.const 2908) ",") + (data $42.1 (i32.const 2920) "\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008") + (data $43 (i32.const 2956) ",") + (data $43.1 (i32.const 2968) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006") + (data $44 (i32.const 3004) ",") + (data $44.1 (i32.const 3016) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006") + (data $45 (i32.const 3052) ",") + (data $45.1 (i32.const 3064) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002") + (data $46 (i32.const 3100) ",") + (data $46.1 (i32.const 3112) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002") + (data $47 (i32.const 3148) ",") + (data $47.1 (i32.const 3160) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004") + (data $48 (i32.const 3196) ",") + (data $48.1 (i32.const 3208) "\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008") + (data $49 (i32.const 3244) ",") + (data $49.1 (i32.const 3256) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006") + (data $50 (i32.const 3292) ",") + (data $50.1 (i32.const 3304) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002") + (data $51 (i32.const 3340) ",") + (data $51.1 (i32.const 3352) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004") + (data $52 (i32.const 3388) "<") + (data $52.1 (i32.const 3400) "\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008") + (data $53 (i32.const 3452) "<") + (data $53.1 (i32.const 3464) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006") + (data $54 (i32.const 3516) "<") + (data $54.1 (i32.const 3528) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002") + (data $55 (i32.const 3580) "<") + (data $55.1 (i32.const 3592) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004") + (data $56 (i32.const 3644) ",") + (data $56.1 (i32.const 3656) "\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P") + (data $57 (i32.const 3692) ",") + (data $57.1 (i32.const 3704) "\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M") + (data $58 (i32.const 3740) ",") + (data $58.1 (i32.const 3752) "\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M") + (data $59 (i32.const 3788) "<") + (data $59.1 (i32.const 3800) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M") + (data $60 (i32.const 3852) "<") + (data $60.1 (i32.const 3864) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M") + (data $61 (i32.const 3916) "<") + (data $61.1 (i32.const 3928) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M") + (data $62 (i32.const 3980) "<") + (data $62.1 (i32.const 3992) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M") + (data $63 (i32.const 4044) "<") + (data $63.1 (i32.const 4056) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M") + (data $64 (i32.const 4108) "<") + (data $64.1 (i32.const 4120) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M") + (data $65 (i32.const 4172) "<") + (data $65.1 (i32.const 4184) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M") + (data $66 (i32.const 4236) "<") + (data $66.1 (i32.const 4248) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M") + (data $67 (i32.const 4300) ",") + (data $67.1 (i32.const 4312) "\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G") + (data $68 (i32.const 4348) "<") + (data $68.1 (i32.const 4360) "\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004") + (data $69 (i32.const 4412) "<") + (data $69.1 (i32.const 4424) "\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002") + (data $70 (i32.const 4476) "<") + (data $70.1 (i32.const 4488) "\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004") + (data $71 (i32.const 4540) "<") + (data $71.1 (i32.const 4552) "\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002") + (data $72 (i32.const 4604) "<") + (data $72.1 (i32.const 4616) "\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004") + (data $73 (i32.const 4668) "<") + (data $73.1 (i32.const 4680) "\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002") + (data $74 (i32.const 4732) ",") + (data $74.1 (i32.const 4744) "\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008") + (data $75 (i32.const 4780) ",") + (data $75.1 (i32.const 4792) "\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006") + (data $76 (i32.const 4828) ",") + (data $76.1 (i32.const 4840) "\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006") + (data $77 (i32.const 4876) ",") + (data $77.1 (i32.const 4888) "\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S") + (data $78 (i32.const 4924) ",") + (data $78.1 (i32.const 4936) "\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008") + (data $79 (i32.const 4972) ",") + (data $79.1 (i32.const 4984) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006") + (data $80 (i32.const 5020) ",") + (data $80.1 (i32.const 5032) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002") + (data $81 (i32.const 5068) ",") + (data $81.1 (i32.const 5080) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004") + (data $82 (i32.const 5116) ",") + (data $82.1 (i32.const 5128) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008") + (data $83 (i32.const 5164) ",") + (data $83.1 (i32.const 5176) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008") + (data $84 (i32.const 5212) ",") + (data $84.1 (i32.const 5224) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006") + (data $85 (i32.const 5260) ",") + (data $85.1 (i32.const 5272) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006") + (data $86 (i32.const 5308) ",") + (data $86.1 (i32.const 5320) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002") + (data $87 (i32.const 5356) ",") + (data $87.1 (i32.const 5368) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002") + (data $88 (i32.const 5404) ",") + (data $88.1 (i32.const 5416) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004") + (data $89 (i32.const 5452) ",") + (data $89.1 (i32.const 5464) "\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002") + (data $90 (i32.const 5500) ",") + (data $90.1 (i32.const 5512) "\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M") + (data $91 (i32.const 5548) ",") + (data $91.1 (i32.const 5560) "\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M") + (data $92 (i32.const 5596) "\1c") + (data $92.1 (i32.const 5608) "\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M") + (data $93 (i32.const 5628) ",") + (data $93.1 (i32.const 5640) "\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002") + (data $94 (i32.const 5676) ",") + (data $94.1 (i32.const 5688) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M") + (data $95 (i32.const 5724) ",") + (data $95.1 (i32.const 5736) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M") + (data $96 (i32.const 5772) ",") + (data $96.1 (i32.const 5784) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002") + (data $97 (i32.const 5820) ",") + (data $97.1 (i32.const 5832) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002") + (data $98 (i32.const 5868) ",") + (data $98.1 (i32.const 5880) "\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002") + (data $99 (i32.const 5916) ",") + (data $99.1 (i32.const 5928) "\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002") + (data $100 (i32.const 5964) ",") + (data $100.1 (i32.const 5976) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M") + (data $101 (i32.const 6012) ",") + (data $101.1 (i32.const 6024) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M") + (data $102 (i32.const 6060) "<") + (data $102.1 (i32.const 6072) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") + (data $103 (i32.const 6124) "<") + (data $103.1 (i32.const 6136) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") + (data $104 (i32.const 6188) "<") + (data $104.1 (i32.const 6200) "\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") + (data $105 (i32.const 6252) ",") + (data $105.1 (i32.const 6264) "\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M") + (data $106 (i32.const 6300) ",") + (data $106.1 (i32.const 6312) "\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M") + (data $107 (i32.const 6348) ",") + (data $107.1 (i32.const 6360) "\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004") + (data $108 (i32.const 6396) ",") + (data $108.1 (i32.const 6408) "\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004") + (data $109 (i32.const 6444) ",") + (data $109.1 (i32.const 6456) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004") + (data $110 (i32.const 6492) ",") + (data $110.1 (i32.const 6504) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004") + (data $111 (i32.const 6540) ",") + (data $111.1 (i32.const 6552) "\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004") + (data $112 (i32.const 6588) ",") + (data $112.1 (i32.const 6600) "\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004") + (data $113 (i32.const 6636) "<") + (data $113.1 (i32.const 6648) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") + (data $114 (i32.const 6700) "<") + (data $114.1 (i32.const 6712) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") + (data $115 (i32.const 6764) "<") + (data $115.1 (i32.const 6776) "\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") + (data $116 (i32.const 6828) ",") + (data $116.1 (i32.const 6840) "\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M") + (data $117 (i32.const 6876) "<") + (data $117.1 (i32.const 6888) "\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T") + (data $118 (i32.const 6940) ",") + (data $118.1 (i32.const 6952) "\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M") + (data $119 (i32.const 6988) "<") + (data $119.1 (i32.const 7000) "\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T") + (data $120 (i32.const 7052) ",") + (data $120.1 (i32.const 7064) "\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q") + (data $121 (i32.const 7100) ",") + (data $121.1 (i32.const 7112) "\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E") + (data $122 (i32.const 7148) ",") + (data $122.1 (i32.const 7160) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U") + (data $123 (i32.const 7196) ",") + (data $123.1 (i32.const 7208) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S") + (data $124 (i32.const 7244) ",") + (data $124.1 (i32.const 7256) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U") + (data $125 (i32.const 7292) ",") + (data $125.1 (i32.const 7304) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S") + (data $126 (i32.const 7340) "<") + (data $126.1 (i32.const 7352) "\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D") + (data $127 (i32.const 7404) "\1c") + (data $127.1 (i32.const 7416) "\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002") + (data $128 (i32.const 7436) "\1c") + (data $128.1 (i32.const 7448) "\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002") + (data $129 (i32.const 7468) "\1c") + (data $129.1 (i32.const 7480) "\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002") + (data $130 (i32.const 7500) ",") + (data $130.1 (i32.const 7512) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002") + (data $131 (i32.const 7548) ",") + (data $131.1 (i32.const 7560) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002") + (data $132 (i32.const 7596) ",") + (data $132.1 (i32.const 7608) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002") + (data $133 (i32.const 7644) ",") + (data $133.1 (i32.const 7656) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002") + (data $134 (i32.const 7692) ",") + (data $134.1 (i32.const 7704) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002") + (data $135 (i32.const 7740) ",") + (data $135.1 (i32.const 7752) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002") + (data $136 (i32.const 7788) ",") + (data $136.1 (i32.const 7800) "\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002") + (data $137 (i32.const 7836) "\1c") + (data $137.1 (i32.const 7848) "\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004") + (data $138 (i32.const 7868) "\1c") + (data $138.1 (i32.const 7880) "\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004") + (data $139 (i32.const 7900) "\1c") + (data $139.1 (i32.const 7912) "\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004") + (data $140 (i32.const 7932) ",") + (data $140.1 (i32.const 7944) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004") + (data $141 (i32.const 7980) ",") + (data $141.1 (i32.const 7992) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004") + (data $142 (i32.const 8028) ",") + (data $142.1 (i32.const 8040) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004") + (data $143 (i32.const 8076) ",") + (data $143.1 (i32.const 8088) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004") + (data $144 (i32.const 8124) ",") + (data $144.1 (i32.const 8136) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004") + (data $145 (i32.const 8172) ",") + (data $145.1 (i32.const 8184) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004") + (data $146 (i32.const 8220) ",") + (data $146.1 (i32.const 8232) "\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004") + (data $147 (i32.const 8268) "\1c") + (data $147.1 (i32.const 8280) "\02\00\00\00\06\00\00\00A\00N\00D") + (data $148 (i32.const 8300) "\1c") + (data $148.1 (i32.const 8312) "\02\00\00\00\06\00\00\00X\00O\00R") + (data $149 (i32.const 8332) "\1c") + (data $149.1 (i32.const 8344) "\02\00\00\00\04\00\00\00O\00R") + (data $150 (i32.const 8364) ",") + (data $150.1 (i32.const 8376) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S") + (data $151 (i32.const 8412) ",") + (data $151.1 (i32.const 8424) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U") + (data $152 (i32.const 8460) ",") + (data $152.1 (i32.const 8472) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U") + (data $153 (i32.const 8508) ",") + (data $153.1 (i32.const 8520) "\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U") + (data $154 (i32.const 8556) ",") + (data $154.1 (i32.const 8568) "\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S") + (data $155 (i32.const 8604) ",") + (data $155.1 (i32.const 8616) "\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z") + (data $156 (i32.const 8652) ",") + (data $156.1 (i32.const 8664) "\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z") + (data $157 (i32.const 8700) ",") + (data $157.1 (i32.const 8712) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004") + (data $158 (i32.const 8748) ",") + (data $158.1 (i32.const 8760) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002") + (data $159 (i32.const 8796) ",") + (data $159.1 (i32.const 8808) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004") + (data $160 (i32.const 8844) ",") + (data $160.1 (i32.const 8856) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002") + (data $161 (i32.const 8892) ",") + (data $161.1 (i32.const 8904) "\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V") + (data $162 (i32.const 8940) "\1c") + (data $162.1 (i32.const 8952) "\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V") + (data $163 (i32.const 8972) "\1c") + (data $163.1 (i32.const 8984) "\02\00\00\00\08\00\00\00X\00N\00O\00R") + (data $164 (i32.const 9004) "\1c") + (data $164.1 (i32.const 9016) "\02\00\00\00\06\00\00\00M\00A\00X") + (data $165 (i32.const 9036) "\1c") + (data $165.1 (i32.const 9048) "\02\00\00\00\n\00\00\00M\00A\00X\00_\00U") + (data $166 (i32.const 9068) "\1c") + (data $166.1 (i32.const 9080) "\02\00\00\00\06\00\00\00M\00I\00N") + (data $167 (i32.const 9100) "\1c") + (data $167.1 (i32.const 9112) "\02\00\00\00\n\00\00\00M\00I\00N\00_\00U") + (data $168 (i32.const 9132) ",") + (data $168.1 (i32.const 9144) "\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s") + (data $169 (i32.const 9180) ",") + (data $169.1 (i32.const 9192) "\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h") + (data $170 (i32.const 9228) "<") + (data $170.1 (i32.const 9240) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s") + (data $171 (i32.const 9292) "<") + (data $171.1 (i32.const 9304) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s") + (data $172 (i32.const 9356) "\1c") + (data $172.1 (i32.const 9368) "\14\00\00\00\08\00\00\00\0e") + (data $173 (i32.const 9388) "\1c") + (data $173.1 (i32.const 9400) "\14\00\00\00\08\00\00\00\0f") + (data $174 (i32.const 9420) "\1c") + (data $174.1 (i32.const 9432) "\14\00\00\00\08\00\00\00\10") + (data $175 (i32.const 9452) "\1c") + (data $175.1 (i32.const 9464) "\14\00\00\00\08\00\00\00\11") + (data $176 (i32.const 9484) "\1c") + (data $176.1 (i32.const 9496) "\14\00\00\00\08\00\00\00\12") + (data $177 (i32.const 9516) "\1c") + (data $177.1 (i32.const 9528) "\14\00\00\00\08\00\00\00\13") + (data $178 (i32.const 9548) "\1c") + (data $178.1 (i32.const 9560) "\14\00\00\00\08\00\00\00\14") + (data $179 (i32.const 9580) "\1c") + (data $179.1 (i32.const 9592) "\14\00\00\00\08\00\00\00\15") + (data $180 (i32.const 9612) "\1c") + (data $180.1 (i32.const 9624) "\14\00\00\00\08\00\00\00\16") + (data $181 (i32.const 9644) "\1c") + (data $181.1 (i32.const 9656) "\14\00\00\00\08\00\00\00\17") + (data $182 (i32.const 9676) "\1c") + (data $182.1 (i32.const 9688) "\14\00\00\00\08\00\00\00\18") + (data $183 (i32.const 9708) "\1c") + (data $183.1 (i32.const 9720) "\14\00\00\00\08\00\00\00\19") + (data $184 (i32.const 9740) "\1c") + (data $184.1 (i32.const 9752) "\14\00\00\00\08\00\00\00\1a") + (data $185 (i32.const 9772) "\1c") + (data $185.1 (i32.const 9784) "\14\00\00\00\08\00\00\00\1b") + (data $186 (i32.const 9804) "\1c") + (data $186.1 (i32.const 9816) "\14\00\00\00\08\00\00\00\1c") + (data $187 (i32.const 9836) "\1c") + (data $187.1 (i32.const 9848) "\14\00\00\00\08\00\00\00\1d") + (data $188 (i32.const 9868) "\1c") + (data $188.1 (i32.const 9880) "\14\00\00\00\08\00\00\00\1e") + (data $189 (i32.const 9900) "\1c") + (data $189.1 (i32.const 9912) "\14\00\00\00\08\00\00\00\1f") + (data $190 (i32.const 9932) "\1c") + (data $190.1 (i32.const 9944) "\14\00\00\00\08\00\00\00 ") + (data $191 (i32.const 9964) "\1c") + (data $191.1 (i32.const 9976) "\14\00\00\00\08\00\00\00!") + (data $192 (i32.const 9996) "\1c") + (data $192.1 (i32.const 10008) "\14\00\00\00\08\00\00\00\"") + (data $193 (i32.const 10028) "\1c") + (data $193.1 (i32.const 10040) "\14\00\00\00\08\00\00\00#") + (data $194 (i32.const 10060) "\1c") + (data $194.1 (i32.const 10072) "\14\00\00\00\08\00\00\00$") + (data $195 (i32.const 10092) "\1c") + (data $195.1 (i32.const 10104) "\14\00\00\00\08\00\00\00%") + (data $196 (i32.const 10124) "\1c") + (data $196.1 (i32.const 10136) "\14\00\00\00\08\00\00\00&") + (data $197 (i32.const 10156) "\1c") + (data $197.1 (i32.const 10168) "\14\00\00\00\08\00\00\00\'") + (data $198 (i32.const 10188) "\1c") + (data $198.1 (i32.const 10200) "\14\00\00\00\08\00\00\00(") + (data $199 (i32.const 10220) "\1c") + (data $199.1 (i32.const 10232) "\14\00\00\00\08\00\00\00)") + (data $200 (i32.const 10252) "\1c") + (data $200.1 (i32.const 10264) "\14\00\00\00\08\00\00\00*") + (data $201 (i32.const 10284) "\1c") + (data $201.1 (i32.const 10296) "\14\00\00\00\08\00\00\00+") + (data $202 (i32.const 10316) "\1c") + (data $202.1 (i32.const 10328) "\14\00\00\00\08\00\00\00,") + (data $203 (i32.const 10348) "\1c") + (data $203.1 (i32.const 10360) "\14\00\00\00\08\00\00\00-") + (data $204 (i32.const 10380) "<") + (data $204.1 (i32.const 10392) "\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t") + (data $205 (i32.const 10444) ",") + (data $205.1 (i32.const 10456) "\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s") + (data $206 (i32.const 10492) "|") + (data $206.1 (i32.const 10504) "\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)") + (data $207 (i32.const 10620) "L") + (data $207.1 (i32.const 10632) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s") + (data $208 (i32.const 10700) "\1c") + (data $208.1 (i32.const 10712) "\14\00\00\00\08\00\00\00.") + (data $209 (i32.const 10732) "\1c") + (data $209.1 (i32.const 10744) "\14\00\00\00\08\00\00\00/") + (data $210 (i32.const 10764) "\1c") + (data $210.1 (i32.const 10776) "\14\00\00\00\08\00\00\000") + (data $211 (i32.const 10796) "\1c") + (data $211.1 (i32.const 10808) "\14\00\00\00\08\00\00\001") + (data $212 (i32.const 10828) "\1c") + (data $212.1 (i32.const 10840) "\14\00\00\00\08\00\00\002") + (data $213 (i32.const 10860) "\1c") + (data $213.1 (i32.const 10872) "\14\00\00\00\08\00\00\003") + (data $214 (i32.const 10892) "\1c") + (data $214.1 (i32.const 10904) "\14\00\00\00\08\00\00\004") + (data $215 (i32.const 10924) "\1c") + (data $215.1 (i32.const 10936) "\14\00\00\00\08\00\00\005") + (data $216 (i32.const 10956) "\1c") + (data $216.1 (i32.const 10968) "\14\00\00\00\08\00\00\006") + (data $217 (i32.const 10988) "\1c") + (data $217.1 (i32.const 11000) "\14\00\00\00\08\00\00\007") + (data $218 (i32.const 11020) "\1c") + (data $218.1 (i32.const 11032) "\14\00\00\00\08\00\00\008") + (data $219 (i32.const 11052) "\1c") + (data $219.1 (i32.const 11064) "\14\00\00\00\08\00\00\009") + (data $220 (i32.const 11084) "\1c") + (data $220.1 (i32.const 11096) "\14\00\00\00\08\00\00\00:") + (data $221 (i32.const 11116) "\1c") + (data $221.1 (i32.const 11128) "\14\00\00\00\08\00\00\00;") + (data $222 (i32.const 11148) "\1c") + (data $222.1 (i32.const 11160) "\14\00\00\00\08\00\00\00<") + (data $223 (i32.const 11180) "\1c") + (data $223.1 (i32.const 11192) "\14\00\00\00\08\00\00\00=") + (data $224 (i32.const 11212) "\1c") + (data $224.1 (i32.const 11224) "\14\00\00\00\08\00\00\00>") + (data $225 (i32.const 11244) "\1c") + (data $225.1 (i32.const 11256) "\14\00\00\00\08\00\00\00?") + (data $226 (i32.const 11276) "\1c") + (data $226.1 (i32.const 11288) "\14\00\00\00\08\00\00\00@") + (data $227 (i32.const 11308) "\1c") + (data $227.1 (i32.const 11320) "\14\00\00\00\08\00\00\00A") + (data $228 (i32.const 11340) "\1c") + (data $228.1 (i32.const 11352) "\14\00\00\00\08\00\00\00B") + (data $229 (i32.const 11372) "\1c") + (data $229.1 (i32.const 11384) "\14\00\00\00\08\00\00\00C") + (data $230 (i32.const 11404) "\1c") + (data $230.1 (i32.const 11416) "\14\00\00\00\08\00\00\00D") + (data $231 (i32.const 11436) "\1c") + (data $231.1 (i32.const 11448) "\14\00\00\00\08\00\00\00E") + (data $232 (i32.const 11468) "\1c") + (data $232.1 (i32.const 11480) "\14\00\00\00\08\00\00\00F") + (data $233 (i32.const 11500) "\1c") + (data $233.1 (i32.const 11512) "\14\00\00\00\08\00\00\00G") + (data $234 (i32.const 11532) "\1c") + (data $234.1 (i32.const 11544) "\14\00\00\00\08\00\00\00H") + (data $235 (i32.const 11564) "\1c") + (data $235.1 (i32.const 11576) "\14\00\00\00\08\00\00\00I") + (data $236 (i32.const 11596) "\1c") + (data $236.1 (i32.const 11608) "\14\00\00\00\08\00\00\00J") + (data $237 (i32.const 11628) "\1c") + (data $237.1 (i32.const 11640) "\14\00\00\00\08\00\00\00K") + (data $238 (i32.const 11660) "\1c") + (data $238.1 (i32.const 11672) "\14\00\00\00\08\00\00\00L") + (data $239 (i32.const 11692) "\1c") + (data $239.1 (i32.const 11704) "\14\00\00\00\08\00\00\00M") + (data $240 (i32.const 11724) "\1c") + (data $240.1 (i32.const 11736) "\14\00\00\00\08\00\00\00N") + (data $241 (i32.const 11756) "\1c") + (data $241.1 (i32.const 11768) "\14\00\00\00\08\00\00\00O") + (data $242 (i32.const 11788) "\1c") + (data $242.1 (i32.const 11800) "\14\00\00\00\08\00\00\00P") + (data $243 (i32.const 11820) "\1c") + (data $243.1 (i32.const 11832) "\14\00\00\00\08\00\00\00Q") + (data $244 (i32.const 11852) "\1c") + (data $244.1 (i32.const 11864) "\14\00\00\00\08\00\00\00R") + (data $245 (i32.const 11884) "\1c") + (data $245.1 (i32.const 11896) "\14\00\00\00\08\00\00\00S") + (data $246 (i32.const 11916) "\1c") + (data $246.1 (i32.const 11928) "\14\00\00\00\08\00\00\00T") + (data $247 (i32.const 11948) "\1c") + (data $247.1 (i32.const 11960) "\14\00\00\00\08\00\00\00U") + (data $248 (i32.const 11980) "\1c") + (data $248.1 (i32.const 11992) "\14\00\00\00\08\00\00\00V") + (data $249 (i32.const 12012) "\1c") + (data $249.1 (i32.const 12024) "\14\00\00\00\08\00\00\00W") + (data $250 (i32.const 12044) "\1c") + (data $250.1 (i32.const 12056) "\14\00\00\00\08\00\00\00X") + (data $251 (i32.const 12076) "\1c") + (data $251.1 (i32.const 12088) "\14\00\00\00\08\00\00\00Y") + (data $252 (i32.const 12108) "\1c") + (data $252.1 (i32.const 12120) "\14\00\00\00\08\00\00\00Z") + (data $253 (i32.const 12140) "\1c") + (data $253.1 (i32.const 12152) "\14\00\00\00\08\00\00\00[") + (data $254 (i32.const 12172) "\1c") + (data $254.1 (i32.const 12184) "\14\00\00\00\08\00\00\00\\") + (data $255 (i32.const 12204) "\1c") + (data $255.1 (i32.const 12216) "\14\00\00\00\08\00\00\00]") + (data $256 (i32.const 12236) "\1c") + (data $256.1 (i32.const 12248) "\14\00\00\00\08\00\00\00^") + (data $257 (i32.const 12268) "\1c") + (data $257.1 (i32.const 12280) "\14\00\00\00\08\00\00\00_") + (data $258 (i32.const 12300) "\1c") + (data $258.1 (i32.const 12312) "\14\00\00\00\08\00\00\00`") + (data $259 (i32.const 12332) "\1c") + (data $259.1 (i32.const 12344) "\14\00\00\00\08\00\00\00a") + (data $260 (i32.const 12364) "\1c") + (data $260.1 (i32.const 12376) "\14\00\00\00\08\00\00\00b") + (data $261 (i32.const 12396) "\1c") + (data $261.1 (i32.const 12408) "\14\00\00\00\08\00\00\00c") + (data $262 (i32.const 12428) "\1c") + (data $262.1 (i32.const 12440) "\14\00\00\00\08\00\00\00d") + (data $263 (i32.const 12460) "\1c") + (data $263.1 (i32.const 12472) "\14\00\00\00\08\00\00\00e") + (data $264 (i32.const 12492) "\1c") + (data $264.1 (i32.const 12504) "\14\00\00\00\08\00\00\00f") + (data $265 (i32.const 12524) "\1c") + (data $265.1 (i32.const 12536) "\14\00\00\00\08\00\00\00g") + (data $266 (i32.const 12556) "\1c") + (data $266.1 (i32.const 12568) "\14\00\00\00\08\00\00\00h") + (data $267 (i32.const 12588) "\1c") + (data $267.1 (i32.const 12600) "\14\00\00\00\08\00\00\00i") + (data $268 (i32.const 12620) "\1c") + (data $268.1 (i32.const 12632) "\14\00\00\00\08\00\00\00j") + (data $269 (i32.const 12652) "\1c") + (data $269.1 (i32.const 12664) "\14\00\00\00\08\00\00\00k") + (data $270 (i32.const 12684) "\1c") + (data $270.1 (i32.const 12696) "\14\00\00\00\08\00\00\00l") + (data $271 (i32.const 12716) "\1c") + (data $271.1 (i32.const 12728) "\14\00\00\00\08\00\00\00m") + (data $272 (i32.const 12748) "\1c") + (data $272.1 (i32.const 12760) "\14\00\00\00\08\00\00\00n") + (data $273 (i32.const 12780) "\1c") + (data $273.1 (i32.const 12792) "\14\00\00\00\08\00\00\00o") + (data $274 (i32.const 12812) "\1c") + (data $274.1 (i32.const 12824) "\14\00\00\00\08\00\00\00p") + (data $275 (i32.const 12844) "\1c") + (data $275.1 (i32.const 12856) "\14\00\00\00\08\00\00\00q") + (data $276 (i32.const 12876) "\1c") + (data $276.1 (i32.const 12888) "\14\00\00\00\08\00\00\00r") + (data $277 (i32.const 12908) "\1c") + (data $277.1 (i32.const 12920) "\14\00\00\00\08\00\00\00s") + (data $278 (i32.const 12940) "\1c") + (data $278.1 (i32.const 12952) "\14\00\00\00\08\00\00\00t") + (data $279 (i32.const 12972) "\1c") + (data $279.1 (i32.const 12984) "\14\00\00\00\08\00\00\00u") + (data $280 (i32.const 13004) "\1c") + (data $280.1 (i32.const 13016) "\14\00\00\00\08\00\00\00v") + (data $281 (i32.const 13036) "\1c") + (data $281.1 (i32.const 13048) "\14\00\00\00\08\00\00\00w") + (data $282 (i32.const 13068) "\1c") + (data $282.1 (i32.const 13080) "\14\00\00\00\08\00\00\00x") + (data $283 (i32.const 13100) "\1c") + (data $283.1 (i32.const 13112) "\14\00\00\00\08\00\00\00y") + (data $284 (i32.const 13132) "\1c") + (data $284.1 (i32.const 13144) "\14\00\00\00\08\00\00\00z") + (data $285 (i32.const 13164) "\1c") + (data $285.1 (i32.const 13176) "\14\00\00\00\08\00\00\00{") + (data $286 (i32.const 13196) "\1c") + (data $286.1 (i32.const 13208) "\14\00\00\00\08\00\00\00|") + (data $287 (i32.const 13228) "\1c") + (data $287.1 (i32.const 13240) "\14\00\00\00\08\00\00\00}") + (data $288 (i32.const 13260) "\1c") + (data $288.1 (i32.const 13272) "\14\00\00\00\08\00\00\00~") + (data $289 (i32.const 13292) "\1c") + (data $289.1 (i32.const 13304) "\14\00\00\00\08\00\00\00\7f") + (data $290 (i32.const 13324) "\1c") + (data $290.1 (i32.const 13336) "\14\00\00\00\08\00\00\00\80") + (data $291 (i32.const 13356) "\1c") + (data $291.1 (i32.const 13368) "\14\00\00\00\08\00\00\00\81") + (data $292 (i32.const 13388) "\1c") + (data $292.1 (i32.const 13400) "\14\00\00\00\08\00\00\00\82") + (data $293 (i32.const 13420) "\1c") + (data $293.1 (i32.const 13432) "\14\00\00\00\08\00\00\00\83") + (data $294 (i32.const 13452) "\1c") + (data $294.1 (i32.const 13464) "\14\00\00\00\08\00\00\00\84") + (data $295 (i32.const 13484) "\1c") + (data $295.1 (i32.const 13496) "\14\00\00\00\08\00\00\00\85") + (data $296 (i32.const 13516) "\1c") + (data $296.1 (i32.const 13528) "\14\00\00\00\08\00\00\00\86") + (data $297 (i32.const 13548) "\1c") + (data $297.1 (i32.const 13560) "\14\00\00\00\08\00\00\00\87") + (data $298 (i32.const 13580) "\1c") + (data $298.1 (i32.const 13592) "\14\00\00\00\08\00\00\00\88") + (data $299 (i32.const 13612) "\1c") + (data $299.1 (i32.const 13624) "\14\00\00\00\08\00\00\00\89") + (data $300 (i32.const 13644) "\1c") + (data $300.1 (i32.const 13656) "\14\00\00\00\08\00\00\00\8a") + (data $301 (i32.const 13676) "\1c") + (data $301.1 (i32.const 13688) "\14\00\00\00\08\00\00\00\8b") + (data $302 (i32.const 13708) "\1c") + (data $302.1 (i32.const 13720) "\14\00\00\00\08\00\00\00\8c") + (data $303 (i32.const 13740) "\1c") + (data $303.1 (i32.const 13752) "\14\00\00\00\08\00\00\00\8d") + (data $304 (i32.const 13772) "\1c") + (data $304.1 (i32.const 13784) "\14\00\00\00\08\00\00\00\8e") + (data $305 (i32.const 13804) "\1c") + (data $305.1 (i32.const 13816) "\14\00\00\00\08\00\00\00\8f") + (data $306 (i32.const 13836) "\1c") + (data $306.1 (i32.const 13848) "\14\00\00\00\08\00\00\00\90") + (data $307 (i32.const 13868) "\1c") + (data $307.1 (i32.const 13880) "\14\00\00\00\08\00\00\00\91") + (data $308 (i32.const 13900) "\1c") + (data $308.1 (i32.const 13912) "\14\00\00\00\08\00\00\00\92") + (data $309 (i32.const 13932) "\1c") + (data $309.1 (i32.const 13944) "\14\00\00\00\08\00\00\00\93") + (data $310 (i32.const 13964) "\1c") + (data $310.1 (i32.const 13976) "\14\00\00\00\08\00\00\00\94") + (data $311 (i32.const 13996) "\1c") + (data $311.1 (i32.const 14008) "\14\00\00\00\08\00\00\00\95") + (data $312 (i32.const 14028) "\1c") + (data $312.1 (i32.const 14040) "\14\00\00\00\08\00\00\00\96") + (data $313 (i32.const 14060) "\1c") + (data $313.1 (i32.const 14072) "\14\00\00\00\08\00\00\00\97") + (data $314 (i32.const 14092) "\1c") + (data $314.1 (i32.const 14104) "\14\00\00\00\08\00\00\00\98") + (data $315 (i32.const 14124) ",") + (data $315.1 (i32.const 14136) "\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y") + (data $316 (i32.const 14172) "\\") + (data $316.1 (i32.const 14184) "\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.") + (data $317 (i32.const 14268) "\1c") + (data $317.1 (i32.const 14280) "\14\00\00\00\08\00\00\00\99") + (data $318 (i32.const 14300) "\ac\03") + (data $318.1 (i32.const 14312) "\01\00\00\00\9c\03\00\00\e06\00\00\007\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 7\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00`(\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c04\00\00\e04\00\00\005\00\00 5\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\e0\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\00(\00\00\80(\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\00`*\00\00\80*\00\00\a0*\00\00@5\00\00`5\00\00\805\00\00\a05\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c05\00\00\e05\00\00\006\00\00 6\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 (\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00\c0&\00\00\e0&\00\00\00\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 0\00\00\d07\00\00\a0$\00\00\c0$\00\00\e0$\00\00\00%\00\00 %\00\00@%\00\00`%\00\00\80%\00\00\a0%\00\00\c0%\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00@6\00\00`6\00\00\806\00\00\a06\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00@+\00\00`+\00\00\80+\00\00\c0,\00\00\a0+\00\00\c0+\00\00\e0+\00\00\e0,\00\00\c01\00\00\e01\00\00\802\00\00\a02\00\00\c02\00\00\00-\00\00\002\00\00 2\00\00\e02\00\00\003\00\00 3\00\00@0\00\00`0\00\00 -\00\00@-\00\00@3\00\00`3\00\00\803\00\00`-\00\00\a03\00\00\c03\00\00\e03\00\00\c00\00\00\e00\00\00\001\00\00 1\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\a0\'\00\00\c0\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00@(\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\80-\00\00\a0-\00\00\c0-\00\00\e0-\00\00\00.\00\00 .\00\00@.\00\00\004\00\00 4\00\00@4\00\00`.\00\00\80.\00\00\a0.\00\00\c0.\00\00\e0.\00\00\00/\00\00 /\00\00`4\00\00\804\00\00\a04\00\00\00,\00\00 ,\00\00@,\00\00@/\00\00`/\00\00\80/\00\00@2\00\00`2\00\00\800\00\00\a00\00\00@1\00\00`1\00\00\801\00\00\a01\00\00`,\00\00\80,\00\00\a0,\00\00\a0/\00\00\c0/\00\00\e0/\00\00\000") + (data $319 (i32.const 15244) ",") + (data $319.1 (i32.const 15256) "\1a\00\00\00\10\00\00\00\f07\00\00\f07\00\00\9c\03\00\00\e7") + (data $320 (i32.const 15292) "\1c") + (data $320.1 (i32.const 15304) "\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80") + (data $321 (i32.const 15324) ",") + (data $321.1 (i32.const 15336) "\1b\00\00\00\10\00\00\00\d0;\00\00\d0;\00\00\08\00\00\00\08") + (data $322 (i32.const 15372) "\1c") + (data $322.1 (i32.const 15384) "\1c\00\00\00\08\00\00\00\9a") + (data $323 (i32.const 15404) "\1c") + (data $323.1 (i32.const 15416) "\02") + (data $324 (i32.const 15436) "L") + (data $324.1 (i32.const 15448) "\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 ") + (data $325 (i32.const 15516) ",") + (data $325.1 (i32.const 15528) "\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 ") + (data $326 (i32.const 15564) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00`<\00\00\00\00\00\00\b0<") + (data $327 (i32.const 15612) "|") + (data $327.1 (i32.const 15624) "\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006") + (data $328 (i32.const 15740) "<") + (data $328.1 (i32.const 15752) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s") + (data $329 (i32.const 15804) "\1c") + (data $329.1 (i32.const 15816) "\02\00\00\00\02\00\00\000") + (data $330 (i32.const 15836) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009") + (data $331 (i32.const 16236) "\1c\04") + (data $331.1 (i32.const 16248) "\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f") + (data $332 (i32.const 17292) "\\") + (data $332.1 (i32.const 17304) "\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z") + (data $333 (i32.const 17388) "<") + (data $333.1 (i32.const 17400) "\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s") + (data $334 (i32.const 17452) "l") + (data $334.1 (i32.const 17464) "\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 ") + (data $335 (i32.const 17564) ",") + (data $335.1 (i32.const 17576) "\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 ") + (data $336 (i32.const 17612) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00@D\00\00\00\00\00\00\b0D") + (data $337 (i32.const 17660) ",") + (data $337.1 (i32.const 17672) "\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n") + (data $338 (i32.const 17708) "\1c") + (data $338.1 (i32.const 17720) "\02\00\00\00\04\00\00\000\00x") + (data $339 (i32.const 17740) "\1c") + (data $339.1 (i32.const 17752) ")\00\00\00\08\00\00\00\9b") + (data $340 (i32.const 17772) "\1c") + (data $340.1 (i32.const 17784) "\02\00\00\00\04\00\00\00\n\00\n") + (data $341 (i32.const 17804) "|") + (data $341.1 (i32.const 17816) "\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y") + (data $342 (i32.const 17932) "L") + (data $342.1 (i32.const 17944) "\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>") + (data $343 (i32.const 18012) "l") + (data $343.1 (i32.const 18024) "\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!") + (data $344 (i32.const 18124) "L") + (data $344.1 (i32.const 18136) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00g\00e\00n\00e\00r\00i\00c\00.\00t\00s") + (data $345 (i32.const 18204) "\1c") + (data $345.1 (i32.const 18216) "\02\00\00\00\02\00\00\00\n") + (data $346 (i32.const 18236) "\1c") + (data $346.1 (i32.const 18248) "\02\00\00\00\04\00\00\00:\00 ") + (data $347 (i32.const 18268) "\1c") + (data $347.1 (i32.const 18280) "\02\00\00\00\02\00\00\00(") + (data $348 (i32.const 18300) "\1c") + (data $348.1 (i32.const 18312) "\02\00\00\00\02\00\00\00)") + (data $349 (i32.const 18332) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pG\00\00\00\00\00\00\90G") + (data $350 (i32.const 18364) "\1c") + (data $350.1 (i32.const 18376) "\02\00\00\00\02\00\00\00 ") + (data $351 (i32.const 18396) "\1c") + (data $351.1 (i32.const 18408) "\02\00\00\00\04\00\00\00,\00 ") + (data $352 (i32.const 18428) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00\d0G\00\00\00\00\00\00\f0G") + (data $353 (i32.const 18460) "|") + (data $353.1 (i32.const 18472) "\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 ") + (data $354 (i32.const 18588) ",") + (data $354.1 (i32.const 18600) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 ") + (data $355 (i32.const 18636) "\1c") + (data $355.1 (i32.const 18648) "\01") + (data $356 (i32.const 18668) "\1c") + (data $356.1 (i32.const 18680) "\01") + (data $357 (i32.const 18700) "\1c") + (data $357.1 (i32.const 18712) "\01") + (data $358 (i32.const 18732) "\1c") + (data $358.1 (i32.const 18744) "\01") + (data $359 (i32.const 18764) "\\") + (data $359.1 (i32.const 18776) "\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 ") + (data $360 (i32.const 18860) "<") + (data $360.1 (i32.const 18872) "\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s") + (data $361 (i32.const 18924) "l") + (data $361.1 (i32.const 18936) "\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!") + (data $362 (i32.const 19036) ",") + (data $362.1 (i32.const 19048) "\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 ") + (data $363 (i32.const 19084) ",") + (data $363.1 (i32.const 19096) "\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)") + (data $364 (i32.const 19132) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pJ\00\00\00\00\00\00\a0J") + (data $365 (i32.const 19164) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pJ\00\00\00\00\00\00\a0J") + (data $366 (i32.const 19196) "\1c") + (data $366.1 (i32.const 19208) "5\00\00\00\08\00\00\00\9c") + (data $367 (i32.const 19228) "<") + (data $367.1 (i32.const 19240) "\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 ") + (data $368 (i32.const 19292) "\1c") + (data $368.1 (i32.const 19304) "\02\00\00\00\n\00\00\00P\00C\00 \00=\00 ") + (data $369 (i32.const 19324) ",") + (data $369.1 (i32.const 19336) "\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 ") + (data $370 (i32.const 19372) "\1c") + (data $370.1 (i32.const 19384) "5\00\00\00\08\00\00\00\9d") + (data $371 (i32.const 19404) ",") + (data $371.1 (i32.const 19416) "\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 ") + (data $372 (i32.const 19452) "\1c") + (data $372.1 (i32.const 19464) "\02\00\00\00\04\00\00\00 \00(") + (data $373 (i32.const 19484) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\14\00\00\00\e0K\00\00\00\00\00\00\10L\00\00\00\00\00\00\90G") + (data $374 (i32.const 19532) "L") + (data $374.1 (i32.const 19544) "\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 ") + (data $375 (i32.const 19612) "<") + (data $375.1 (i32.const 19624) "\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s") + (data $376 (i32.const 19676) ",") + (data $376.1 (i32.const 19688) "\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 ") + (data $377 (i32.const 19724) "\1c") + (data $377.1 (i32.const 19736) "\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x") + (data $378 (i32.const 19756) "\1c") + (data $378.1 (i32.const 19768) "\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 ") + (data $379 (i32.const 19788) "\1c") + (data $379.1 (i32.const 19800) "\02\00\00\00\08\00\00\00,\00\n\00 \00 ") + (data $380 (i32.const 19820) "|\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00`\00\00\00\f0L\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00@M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00`M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00`M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M") + (data $381 (i32.const 19948) ",") + (data $381.1 (i32.const 19960) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t") + (data $382 (i32.const 19996) "L") + (data $382.1 (i32.const 20008) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s") + (data $383 (i32.const 20076) "\1c") + (data $383.1 (i32.const 20088) "\01") + (data $384 (i32.const 20108) "\1c") + (data $384.1 (i32.const 20120) "\01") + (data $385 (i32.const 20140) "\1c") + (data $385.1 (i32.const 20152) "\01") + (data $386 (i32.const 20172) "\1c") + (data $386.1 (i32.const 20184) "\01") + (data $387 (i32.const 20204) "L") + (data $387.1 (i32.const 20216) "\02\00\00\00:\00\00\00S\00P\00I\00 \00r\00u\00n\00n\00i\00n\00g\00 \00n\00o\00t\00 \00s\00u\00p\00p\00o\00r\00t\00e\00d\00 \00y\00e\00t") + (data $388 (i32.const 20284) "<") + (data $388.1 (i32.const 20296) "\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00d\00e\00x\00.\00t\00s") + (data $389 (i32.const 20348) "L") + (data $389.1 (i32.const 20360) "\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s") + (data $390 (i32.const 20428) "\1c") + (data $390.1 (i32.const 20440) "\01") + (data $391 (i32.const 20460) "<") + (data $391.1 (i32.const 20472) "\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s") + (data $392 (i32.const 20524) "L") + (data $392.1 (i32.const 20536) "\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 ") + (data $393 (i32.const 20604) "\\") + (data $393.1 (i32.const 20616) "\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 ") + (data $394 (i32.const 20700) ",") + (data $394.1 (i32.const 20712) "\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 ") + (data $395 (i32.const 20748) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00\90P\00\00\00\00\00\00\f0P") + (data $396 (i32.const 20796) "<") + (data $396.1 (i32.const 20808) "\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00.\00t\00s") + (data $397 (i32.const 20860) "\1c") + (data $397.1 (i32.const 20872) "\01") + (data $398 (i32.const 20892) "\1c") + (data $398.1 (i32.const 20904) "\01") + (data $399 (i32.const 20924) "<") + (data $399.1 (i32.const 20936) "\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d") + (data $400 (i32.const 20988) "<") + (data $400.1 (i32.const 21000) "\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d") + (data $401 (i32.const 21056) "<\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 ") + (data $401.1 (i32.const 21116) "$\02") + (data $401.2 (i32.const 21128) "\02A\00\00\10A\02\00 ") + (data $401.3 (i32.const 21152) "d") + (data $401.4 (i32.const 21164) "\02A\00\00B") + (data $401.5 (i32.const 21188) "$\01") + (data $401.6 (i32.const 21200) "$\t\00\00 ") + (data $401.7 (i32.const 21216) "\04A\00\00 \00\00\00\00\00\00\00\02\01\00\00\02\02") + (data $401.8 (i32.const 21244) "\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A") + (data $401.9 (i32.const 21280) " \00\00\00 \00\00\00\02A\00\00d") + (table $0 158 158 funcref) + (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $assembly/index/disassemble~anonymous|0 $assembly/api-generic/runVm~anonymous|0 $assembly/api-generic/runVm~anonymous|0) + (export "InputKind.Generic" (global $assembly/index/InputKind.Generic)) + (export "InputKind.SPI" (global $assembly/index/InputKind.SPI)) + (export "HasMetadata.Yes" (global $assembly/index/HasMetadata.Yes)) + (export "HasMetadata.No" (global $assembly/index/HasMetadata.No)) + (export "nextStep" (func $assembly/api/nextStep)) + (export "nSteps" (func $assembly/api/nSteps)) + (export "getProgramCounter" (func $assembly/api/getProgramCounter)) + (export "setNextProgramCounter" (func $assembly/api/setNextProgramCounter)) + (export "getStatus" (func $assembly/api/getStatus)) + (export "getExitArg" (func $assembly/api/getExitArg)) + (export "getGasLeft" (func $assembly/api/getGasLeft)) + (export "setGasLeft" (func $assembly/api/setGasLeft)) + (export "getRegisters" (func $assembly/api/getRegisters)) + (export "getPageDump" (func $assembly/api/getPageDump)) + (export "__new" (func $~lib/rt/itcms/__new)) + (export "__pin" (func $~lib/rt/itcms/__pin)) + (export "__unpin" (func $~lib/rt/itcms/__unpin)) + (export "__collect" (func $~lib/rt/itcms/__collect)) + (export "__rtti_base" (global $~lib/rt/__rtti_base)) + (export "memory" (memory $0)) + (export "__setArgumentsLength" (func $~setArgumentsLength)) + (export "disassemble" (func $export:assembly/index/disassemble)) + (export "runProgram" (func $export:assembly/index/runProgram)) + (export "runVm" (func $export:assembly/api-generic/runVm@varargs)) + (export "getAssembly" (func $export:assembly/api-generic/getAssembly)) + (export "wrapAsProgram" (func $export:assembly/program-build/wrapAsProgram)) + (export "resetGeneric" (func $export:assembly/api/resetGeneric)) + (export "resetGenericWithMemory" (func $export:assembly/api/resetGenericWithMemory)) + (export "setRegisters" (func $export:assembly/api/setRegisters)) + (export "setMemory" (func $export:assembly/api/setMemory)) + (start $~start) + (func $~lib/rt/itcms/visitRoots + (local $0 i32) + (local $1 i32) + i32.const 1504 + call $~lib/rt/itcms/__visit + i32.const 9200 + call $~lib/rt/itcms/__visit + i32.const 14144 + call $~lib/rt/itcms/__visit + i32.const 17824 + call $~lib/rt/itcms/__visit + i32.const 10400 + call $~lib/rt/itcms/__visit + i32.const 1312 + call $~lib/rt/itcms/__visit + i32.const 20944 + call $~lib/rt/itcms/__visit + i32.const 21008 + call $~lib/rt/itcms/__visit + i32.const 16256 + call $~lib/rt/itcms/__visit + i32.const 17312 + call $~lib/rt/itcms/__visit + global.get $assembly/api/interpreter + local.tee $0 + if + local.get $0 + call $~lib/rt/itcms/__visit + end + i32.const 1136 + call $~lib/rt/itcms/__visit + i32.const 1264 + call $~lib/rt/itcms/__visit + i32.const 2272 + call $~lib/rt/itcms/__visit + global.get $assembly/instructions/INSTRUCTIONS + local.tee $0 + if + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $0 + if + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $0 + if + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_PAGE + local.tee $0 + if + local.get $0 + call $~lib/rt/itcms/__visit + end + i32.const 15344 + call $~lib/rt/itcms/__visit + i32.const 15264 + call $~lib/rt/itcms/__visit + global.get $~lib/rt/itcms/pinSpace + local.tee $1 + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + loop $while-continue|0 + local.get $0 + local.get $1 + i32.ne + if + local.get $0 + i32.load offset=4 + i32.const 3 + i32.and + i32.const 3 + i32.ne + if + i32.const 0 + i32.const 1376 + i32.const 160 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.const 20 + i32.add + call $~lib/rt/__visit_members + local.get $0 + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + br $while-continue|0 + end + end + ) + (func $~lib/rt/itcms/Object#unlink (param $0 i32) + (local $1 i32) + local.get $0 + i32.load offset=4 + i32.const -4 + i32.and + local.tee $1 + i32.eqz + if + local.get $0 + i32.load offset=8 + i32.eqz + local.get $0 + i32.const 54068 + i32.lt_u + i32.and + i32.eqz + if + i32.const 0 + i32.const 1376 + i32.const 128 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + return + end + local.get $0 + i32.load offset=8 + local.tee $0 + i32.eqz + if + i32.const 0 + i32.const 1376 + i32.const 132 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $1 + local.get $0 + i32.store offset=8 + local.get $0 + local.get $1 + local.get $0 + i32.load offset=4 + i32.const 3 + i32.and + i32.or + i32.store offset=4 + ) + (func $~lib/rt/itcms/Object#makeGray (param $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + local.get $0 + global.get $~lib/rt/itcms/iter + i32.eq + if + local.get $0 + i32.load offset=8 + local.tee $1 + i32.eqz + if + i32.const 0 + i32.const 1376 + i32.const 148 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $1 + global.set $~lib/rt/itcms/iter + end + local.get $0 + call $~lib/rt/itcms/Object#unlink + global.get $~lib/rt/itcms/toSpace + local.set $1 + local.get $0 + i32.load offset=12 + local.tee $2 + i32.const 2 + i32.le_u + if (result i32) + i32.const 1 + else + local.get $2 + i32.const 21056 + i32.load + i32.gt_u + if + i32.const 1504 + i32.const 1568 + i32.const 21 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $2 + i32.const 2 + i32.shl + i32.const 21060 + i32.add + i32.load + i32.const 32 + i32.and + end + local.set $3 + local.get $1 + i32.load offset=8 + local.set $2 + local.get $0 + global.get $~lib/rt/itcms/white + i32.eqz + i32.const 2 + local.get $3 + select + local.get $1 + i32.or + i32.store offset=4 + local.get $0 + local.get $2 + i32.store offset=8 + local.get $2 + local.get $0 + local.get $2 + i32.load offset=4 + i32.const 3 + i32.and + i32.or + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=8 + ) + (func $~lib/rt/itcms/__visit (param $0 i32) + local.get $0 + i32.eqz + if + return + end + global.get $~lib/rt/itcms/white + local.get $0 + i32.const 20 + i32.sub + local.tee $0 + i32.load offset=4 + i32.const 3 + i32.and + i32.eq + if + local.get $0 + call $~lib/rt/itcms/Object#makeGray + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.add + global.set $~lib/rt/itcms/visitCount + end + ) + (func $~lib/rt/tlsf/removeBlock (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + local.get $1 + i32.load + local.tee $3 + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 268 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.const -4 + i32.and + local.tee $3 + i32.const 12 + i32.lt_u + if + i32.const 0 + i32.const 1648 + i32.const 270 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.const 256 + i32.lt_u + if (result i32) + local.get $3 + i32.const 4 + i32.shr_u + else + i32.const 31 + i32.const 1073741820 + local.get $3 + local.get $3 + i32.const 1073741820 + i32.ge_u + select + local.tee $3 + i32.clz + i32.sub + local.tee $4 + i32.const 7 + i32.sub + local.set $2 + local.get $3 + local.get $4 + i32.const 4 + i32.sub + i32.shr_u + i32.const 16 + i32.xor + end + local.tee $3 + i32.const 16 + i32.lt_u + local.get $2 + i32.const 23 + i32.lt_u + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 284 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.load offset=8 + local.set $5 + local.get $1 + i32.load offset=4 + local.tee $4 + if + local.get $4 + local.get $5 + i32.store offset=8 + end + local.get $5 + if + local.get $5 + local.get $4 + i32.store offset=4 + end + local.get $1 + local.get $0 + local.get $2 + i32.const 4 + i32.shl + local.get $3 + i32.add + i32.const 2 + i32.shl + i32.add + local.tee $1 + i32.load offset=96 + i32.eq + if + local.get $1 + local.get $5 + i32.store offset=96 + local.get $5 + i32.eqz + if + local.get $0 + local.get $2 + i32.const 2 + i32.shl + i32.add + local.tee $1 + i32.load offset=4 + i32.const -2 + local.get $3 + i32.rotl + i32.and + local.set $3 + local.get $1 + local.get $3 + i32.store offset=4 + local.get $3 + i32.eqz + if + local.get $0 + local.get $0 + i32.load + i32.const -2 + local.get $2 + i32.rotl + i32.and + i32.store + end + end + end + ) + (func $~lib/rt/tlsf/insertBlock (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + local.get $1 + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 201 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.load + local.tee $3 + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 203 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.const 4 + i32.add + local.get $1 + i32.load + i32.const -4 + i32.and + i32.add + local.tee $4 + i32.load + local.tee $2 + i32.const 1 + i32.and + if + local.get $0 + local.get $4 + call $~lib/rt/tlsf/removeBlock + local.get $1 + local.get $3 + i32.const 4 + i32.add + local.get $2 + i32.const -4 + i32.and + i32.add + local.tee $3 + i32.store + local.get $1 + i32.const 4 + i32.add + local.get $1 + i32.load + i32.const -4 + i32.and + i32.add + local.tee $4 + i32.load + local.set $2 + end + local.get $3 + i32.const 2 + i32.and + if + local.get $1 + i32.const 4 + i32.sub + i32.load + local.tee $1 + i32.load + local.tee $6 + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 221 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + call $~lib/rt/tlsf/removeBlock + local.get $1 + local.get $6 + i32.const 4 + i32.add + local.get $3 + i32.const -4 + i32.and + i32.add + local.tee $3 + i32.store + end + local.get $4 + local.get $2 + i32.const 2 + i32.or + i32.store + local.get $3 + i32.const -4 + i32.and + local.tee $2 + i32.const 12 + i32.lt_u + if + i32.const 0 + i32.const 1648 + i32.const 233 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $4 + local.get $1 + i32.const 4 + i32.add + local.get $2 + i32.add + i32.ne + if + i32.const 0 + i32.const 1648 + i32.const 234 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $4 + i32.const 4 + i32.sub + local.get $1 + i32.store + local.get $2 + i32.const 256 + i32.lt_u + if (result i32) + local.get $2 + i32.const 4 + i32.shr_u + else + i32.const 31 + i32.const 1073741820 + local.get $2 + local.get $2 + i32.const 1073741820 + i32.ge_u + select + local.tee $2 + i32.clz + i32.sub + local.tee $3 + i32.const 7 + i32.sub + local.set $5 + local.get $2 + local.get $3 + i32.const 4 + i32.sub + i32.shr_u + i32.const 16 + i32.xor + end + local.tee $2 + i32.const 16 + i32.lt_u + local.get $5 + i32.const 23 + i32.lt_u + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 251 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $5 + i32.const 4 + i32.shl + local.get $2 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + local.set $3 + local.get $1 + i32.const 0 + i32.store offset=4 + local.get $1 + local.get $3 + i32.store offset=8 + local.get $3 + if + local.get $3 + local.get $1 + i32.store offset=4 + end + local.get $0 + local.get $5 + i32.const 4 + i32.shl + local.get $2 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $1 + i32.store offset=96 + local.get $0 + local.get $0 + i32.load + i32.const 1 + local.get $5 + i32.shl + i32.or + i32.store + local.get $0 + local.get $5 + i32.const 2 + i32.shl + i32.add + local.tee $0 + local.get $0 + i32.load offset=4 + i32.const 1 + local.get $2 + i32.shl + i32.or + i32.store offset=4 + ) + (func $~lib/rt/tlsf/addMemory (param $0 i32) (param $1 i32) (param $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + local.get $2 + local.get $1 + i64.extend_i32_u + i64.lt_u + if + i32.const 0 + i32.const 1648 + i32.const 382 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.const 19 + i32.add + i32.const -16 + i32.and + i32.const 4 + i32.sub + local.set $1 + local.get $0 + i32.load offset=1568 + local.tee $3 + if + local.get $3 + i32.const 4 + i32.add + local.get $1 + i32.gt_u + if + i32.const 0 + i32.const 1648 + i32.const 389 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $3 + local.get $1 + i32.const 16 + i32.sub + local.tee $5 + i32.eq + if + local.get $3 + i32.load + local.set $4 + local.get $5 + local.set $1 + end + else + local.get $0 + i32.const 1572 + i32.add + local.get $1 + i32.gt_u + if + i32.const 0 + i32.const 1648 + i32.const 402 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + end + local.get $2 + i32.wrap_i64 + i32.const -16 + i32.and + local.get $1 + i32.sub + local.tee $3 + i32.const 20 + i32.lt_u + if + return + end + local.get $1 + local.get $4 + i32.const 2 + i32.and + local.get $3 + i32.const 8 + i32.sub + local.tee $3 + i32.const 1 + i32.or + i32.or + i32.store + local.get $1 + i32.const 0 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=8 + local.get $1 + i32.const 4 + i32.add + local.get $3 + i32.add + local.tee $3 + i32.const 2 + i32.store + local.get $0 + local.get $3 + i32.store offset=1568 + local.get $0 + local.get $1 + call $~lib/rt/tlsf/insertBlock + ) + (func $~lib/rt/tlsf/initialize + (local $0 i32) + (local $1 i32) + memory.size + local.tee $1 + i32.const 0 + i32.le_s + if (result i32) + i32.const 1 + local.get $1 + i32.sub + memory.grow + i32.const 0 + i32.lt_s + else + i32.const 0 + end + if + unreachable + end + i32.const 54080 + i32.const 0 + i32.store + i32.const 55648 + i32.const 0 + i32.store + loop $for-loop|0 + local.get $0 + i32.const 23 + i32.lt_u + if + local.get $0 + i32.const 2 + i32.shl + i32.const 54080 + i32.add + i32.const 0 + i32.store offset=4 + i32.const 0 + local.set $1 + loop $for-loop|1 + local.get $1 + i32.const 16 + i32.lt_u + if + local.get $0 + i32.const 4 + i32.shl + local.get $1 + i32.add + i32.const 2 + i32.shl + i32.const 54080 + i32.add + i32.const 0 + i32.store offset=96 + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|1 + end + end + local.get $0 + i32.const 1 + i32.add + local.set $0 + br $for-loop|0 + end + end + i32.const 54080 + i32.const 55652 + memory.size + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + i32.const 54080 + global.set $~lib/rt/tlsf/ROOT + ) + (func $~lib/rt/itcms/step (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i32) + block $break|0 + block $case2|0 + block $case1|0 + block $case0|0 + global.get $~lib/rt/itcms/state + br_table $case0|0 $case1|0 $case2|0 $break|0 + end + i32.const 1 + global.set $~lib/rt/itcms/state + i32.const 0 + global.set $~lib/rt/itcms/visitCount + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/iter + global.get $~lib/rt/itcms/visitCount + return + end + global.get $~lib/rt/itcms/white + i32.eqz + local.set $1 + global.get $~lib/rt/itcms/iter + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + loop $while-continue|1 + local.get $0 + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $0 + global.set $~lib/rt/itcms/iter + local.get $1 + local.get $0 + i32.load offset=4 + local.tee $2 + i32.const 3 + i32.and + i32.ne + if + local.get $0 + local.get $2 + i32.const -4 + i32.and + local.get $1 + i32.or + i32.store offset=4 + i32.const 0 + global.set $~lib/rt/itcms/visitCount + local.get $0 + i32.const 20 + i32.add + call $~lib/rt/__visit_members + global.get $~lib/rt/itcms/visitCount + return + end + local.get $0 + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + br $while-continue|1 + end + end + i32.const 0 + global.set $~lib/rt/itcms/visitCount + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/iter + i32.load offset=4 + i32.const -4 + i32.and + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.set $0 + loop $while-continue|0 + local.get $0 + i32.const 54068 + i32.lt_u + if + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + local.get $0 + i32.const 4 + i32.add + local.set $0 + br $while-continue|0 + end + end + global.get $~lib/rt/itcms/iter + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + loop $while-continue|2 + local.get $0 + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $1 + local.get $0 + i32.load offset=4 + local.tee $2 + i32.const 3 + i32.and + i32.ne + if + local.get $0 + local.get $2 + i32.const -4 + i32.and + local.get $1 + i32.or + i32.store offset=4 + local.get $0 + i32.const 20 + i32.add + call $~lib/rt/__visit_members + end + local.get $0 + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + br $while-continue|2 + end + end + global.get $~lib/rt/itcms/fromSpace + local.set $0 + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/fromSpace + local.get $0 + global.set $~lib/rt/itcms/toSpace + local.get $1 + global.set $~lib/rt/itcms/white + local.get $0 + i32.load offset=4 + i32.const -4 + i32.and + global.set $~lib/rt/itcms/iter + i32.const 2 + global.set $~lib/rt/itcms/state + end + global.get $~lib/rt/itcms/visitCount + return + end + global.get $~lib/rt/itcms/iter + local.tee $0 + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $0 + i32.load offset=4 + local.tee $1 + i32.const -4 + i32.and + global.set $~lib/rt/itcms/iter + global.get $~lib/rt/itcms/white + i32.eqz + local.get $1 + i32.const 3 + i32.and + i32.ne + if + i32.const 0 + i32.const 1376 + i32.const 229 + i32.const 20 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.const 54068 + i32.lt_u + if + local.get $0 + i32.const 0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=8 + else + global.get $~lib/rt/itcms/total + local.get $0 + i32.load + i32.const -4 + i32.and + i32.const 4 + i32.add + i32.sub + global.set $~lib/rt/itcms/total + local.get $0 + i32.const 4 + i32.add + local.tee $0 + i32.const 54068 + i32.ge_u + if + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $0 + i32.const 4 + i32.sub + local.set $2 + local.get $0 + i32.const 15 + i32.and + i32.const 1 + local.get $0 + select + if (result i32) + i32.const 1 + else + local.get $2 + i32.load + i32.const 1 + i32.and + end + if + i32.const 0 + i32.const 1648 + i32.const 562 + i32.const 3 + call $~lib/builtins/abort + unreachable + end + local.get $2 + local.get $2 + i32.load + i32.const 1 + i32.or + i32.store + local.get $2 + call $~lib/rt/tlsf/insertBlock + end + end + i32.const 10 + return + end + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + i32.store offset=4 + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + i32.store offset=8 + i32.const 0 + global.set $~lib/rt/itcms/state + end + i32.const 0 + ) + (func $~lib/rt/tlsf/searchBlock (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + local.get $1 + i32.const 256 + i32.lt_u + if + local.get $1 + i32.const 4 + i32.shr_u + local.set $1 + else + local.get $1 + i32.const 536870910 + i32.lt_u + if + local.get $1 + i32.const 1 + i32.const 27 + local.get $1 + i32.clz + i32.sub + i32.shl + i32.add + i32.const 1 + i32.sub + local.set $1 + end + local.get $1 + i32.const 31 + local.get $1 + i32.clz + i32.sub + local.tee $2 + i32.const 4 + i32.sub + i32.shr_u + i32.const 16 + i32.xor + local.set $1 + local.get $2 + i32.const 7 + i32.sub + local.set $2 + end + local.get $1 + i32.const 16 + i32.lt_u + local.get $2 + i32.const 23 + i32.lt_u + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 334 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $2 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + i32.const -1 + local.get $1 + i32.shl + i32.and + local.tee $1 + if (result i32) + local.get $0 + local.get $1 + i32.ctz + local.get $2 + i32.const 4 + i32.shl + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + else + local.get $0 + i32.load + i32.const -1 + local.get $2 + i32.const 1 + i32.add + i32.shl + i32.and + local.tee $1 + if (result i32) + local.get $0 + local.get $1 + i32.ctz + local.tee $1 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + local.tee $2 + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 347 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $2 + i32.ctz + local.get $1 + i32.const 4 + i32.shl + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + else + i32.const 0 + end + end + ) + (func $~lib/rt/tlsf/allocateBlock (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + local.get $1 + i32.const 1073741820 + i32.gt_u + if + i32.const 1312 + i32.const 1648 + i32.const 461 + i32.const 29 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 12 + i32.le_u + if (result i32) + i32.const 12 + else + local.get $1 + i32.const 19 + i32.add + i32.const -16 + i32.and + i32.const 4 + i32.sub + end + local.tee $3 + call $~lib/rt/tlsf/searchBlock + local.tee $1 + i32.eqz + if + memory.size + local.tee $1 + local.get $3 + i32.const 256 + i32.ge_u + if (result i32) + local.get $3 + i32.const 536870910 + i32.lt_u + if (result i32) + local.get $3 + i32.const 1 + i32.const 27 + local.get $3 + i32.clz + i32.sub + i32.shl + i32.add + i32.const 1 + i32.sub + else + local.get $3 + end + else + local.get $3 + end + i32.const 4 + local.get $0 + i32.load offset=1568 + local.get $1 + i32.const 16 + i32.shl + i32.const 4 + i32.sub + i32.ne + i32.shl + i32.add + i32.const 65535 + i32.add + i32.const -65536 + i32.and + i32.const 16 + i32.shr_u + local.tee $2 + local.get $1 + local.get $2 + i32.gt_s + select + memory.grow + i32.const 0 + i32.lt_s + if + local.get $2 + memory.grow + i32.const 0 + i32.lt_s + if + unreachable + end + end + local.get $0 + local.get $1 + i32.const 16 + i32.shl + memory.size + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + local.get $0 + local.get $3 + call $~lib/rt/tlsf/searchBlock + local.tee $1 + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 499 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + end + local.get $3 + local.get $1 + i32.load + i32.const -4 + i32.and + i32.gt_u + if + i32.const 0 + i32.const 1648 + i32.const 501 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + call $~lib/rt/tlsf/removeBlock + local.get $1 + i32.load + local.set $4 + local.get $3 + i32.const 4 + i32.add + i32.const 15 + i32.and + if + i32.const 0 + i32.const 1648 + i32.const 361 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $4 + i32.const -4 + i32.and + local.get $3 + i32.sub + local.tee $2 + i32.const 16 + i32.ge_u + if + local.get $1 + local.get $3 + local.get $4 + i32.const 2 + i32.and + i32.or + i32.store + local.get $1 + i32.const 4 + i32.add + local.get $3 + i32.add + local.tee $3 + local.get $2 + i32.const 4 + i32.sub + i32.const 1 + i32.or + i32.store + local.get $0 + local.get $3 + call $~lib/rt/tlsf/insertBlock + else + local.get $1 + local.get $4 + i32.const -2 + i32.and + i32.store + local.get $1 + i32.const 4 + i32.add + local.get $1 + i32.load + i32.const -4 + i32.and + i32.add + local.tee $0 + local.get $0 + i32.load + i32.const -3 + i32.and + i32.store + end + local.get $1 + ) + (func $~lib/rt/itcms/__new (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + local.get $0 + i32.const 1073741804 + i32.ge_u + if + i32.const 1312 + i32.const 1376 + i32.const 261 + i32.const 31 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.ge_u + if + block $__inlined_func$~lib/rt/itcms/interrupt$69 + i32.const 2048 + local.set $2 + loop $do-loop|0 + local.get $2 + call $~lib/rt/itcms/step + i32.sub + local.set $2 + global.get $~lib/rt/itcms/state + i32.eqz + if + global.get $~lib/rt/itcms/total + i64.extend_i32_u + i64.const 200 + i64.mul + i64.const 100 + i64.div_u + i32.wrap_i64 + i32.const 1024 + i32.add + global.set $~lib/rt/itcms/threshold + br $__inlined_func$~lib/rt/itcms/interrupt$69 + end + local.get $2 + i32.const 0 + i32.gt_s + br_if $do-loop|0 + end + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.sub + i32.const 1024 + i32.lt_u + i32.const 10 + i32.shl + i32.add + global.set $~lib/rt/itcms/threshold + end + end + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $0 + i32.const 16 + i32.add + call $~lib/rt/tlsf/allocateBlock + local.tee $2 + local.get $1 + i32.store offset=12 + local.get $2 + local.get $0 + i32.store offset=16 + global.get $~lib/rt/itcms/fromSpace + local.tee $1 + i32.load offset=8 + local.set $3 + local.get $2 + local.get $1 + global.get $~lib/rt/itcms/white + i32.or + i32.store offset=4 + local.get $2 + local.get $3 + i32.store offset=8 + local.get $3 + local.get $2 + local.get $3 + i32.load offset=4 + i32.const 3 + i32.and + i32.or + i32.store offset=4 + local.get $1 + local.get $2 + i32.store offset=8 + global.get $~lib/rt/itcms/total + local.get $2 + i32.load + i32.const -4 + i32.and + i32.const 4 + i32.add + i32.add + global.set $~lib/rt/itcms/total + local.get $2 + i32.const 20 + i32.add + local.tee $1 + i32.const 0 + local.get $0 + memory.fill + local.get $1 + ) + (func $start:assembly/arguments~anonymous|0 (param $0 i32) (param $1 i32) (result i32) + i32.const 0 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + ) + (func $~lib/rt/itcms/__link (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + local.get $1 + i32.eqz + if + return + end + local.get $0 + i32.eqz + if + i32.const 0 + i32.const 1376 + i32.const 295 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/white + local.get $1 + i32.const 20 + i32.sub + local.tee $1 + i32.load offset=4 + i32.const 3 + i32.and + i32.eq + if + local.get $0 + i32.const 20 + i32.sub + local.tee $0 + i32.load offset=4 + i32.const 3 + i32.and + local.tee $3 + global.get $~lib/rt/itcms/white + i32.eqz + i32.eq + if + local.get $0 + local.get $1 + local.get $2 + select + call $~lib/rt/itcms/Object#makeGray + else + global.get $~lib/rt/itcms/state + i32.const 1 + i32.eq + local.get $3 + i32.const 3 + i32.eq + i32.and + if + local.get $1 + call $~lib/rt/itcms/Object#makeGray + end + end + end + ) + (func $assembly/instructions/instruction (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + i32.const 17 + call $~lib/rt/tlsf/allocateBlock + i32.const 4 + i32.add + local.tee $3 + i32.const 0 + i32.store + local.get $3 + i32.const 0 + i32.store offset=4 + local.get $3 + i64.const 0 + i64.store offset=8 + local.get $3 + i32.const 0 + i32.store8 offset=16 + local.get $3 + local.get $0 + i32.store + local.get $3 + local.get $1 + i32.store offset=4 + local.get $3 + i64.const 1 + i64.store offset=8 + local.get $3 + local.get $2 + i32.store8 offset=16 + local.get $3 + ) + (func $start:assembly/instructions/misc~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $start:assembly/instructions/misc~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + call $assembly/instructions/outcome/OutcomeData#constructor + ) + (func $~lib/util/number/utoa32_dec_lut (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + loop $while-continue|0 + local.get $1 + i32.const 10000 + i32.ge_u + if + local.get $1 + i32.const 10000 + i32.rem_u + local.set $3 + local.get $1 + i32.const 10000 + i32.div_u + local.set $1 + local.get $0 + local.get $2 + i32.const 4 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $3 + i32.const 100 + i32.div_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + local.get $3 + i32.const 100 + i32.rem_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $1 + i32.const 100 + i32.ge_u + if + local.get $0 + local.get $2 + i32.const 2 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $1 + i32.const 100 + i32.rem_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i32.load + i32.store + local.get $1 + i32.const 100 + i32.div_u + local.set $1 + end + local.get $1 + i32.const 10 + i32.ge_u + if + local.get $0 + local.get $2 + i32.const 2 + i32.sub + i32.const 1 + i32.shl + i32.add + local.get $1 + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i32.load + i32.store + else + local.get $0 + local.get $2 + i32.const 1 + i32.sub + i32.const 1 + i32.shl + i32.add + local.get $1 + i32.const 48 + i32.add + i32.store16 + end + ) + (func $~lib/util/number/utoa64_any_core (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) + (local $4 i64) + (local $5 i64) + local.get $3 + i64.extend_i32_s + local.set $5 + local.get $3 + local.get $3 + i32.const 1 + i32.sub + i32.and + if + loop $do-loop|1 + local.get $0 + local.get $2 + i32.const 1 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $1 + local.get $1 + local.get $5 + i64.div_u + local.tee $1 + local.get $5 + i64.mul + i64.sub + i32.wrap_i64 + i32.const 1 + i32.shl + i32.const 17312 + i32.add + i32.load16_u + i32.store16 + local.get $1 + i64.const 0 + i64.ne + br_if $do-loop|1 + end + else + local.get $3 + i32.ctz + i32.const 7 + i32.and + i64.extend_i32_s + local.set $4 + local.get $5 + i64.const 1 + i64.sub + local.set $5 + loop $do-loop|0 + local.get $0 + local.get $2 + i32.const 1 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $1 + local.get $5 + i64.and + i32.wrap_i64 + i32.const 1 + i32.shl + i32.const 17312 + i32.add + i32.load16_u + i32.store16 + local.get $1 + local.get $4 + i64.shr_u + local.tee $1 + i64.const 0 + i64.ne + br_if $do-loop|0 + end + end + ) + (func $~lib/number/I32#toString (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $__inlined_func$~lib/util/number/itoa32$98 + local.get $0 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15824 + local.set $0 + br $__inlined_func$~lib/util/number/itoa32$98 + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $0 + i32.sub + local.get $0 + local.get $0 + i32.const 31 + i32.shr_u + i32.const 1 + i32.shl + local.tee $1 + select + local.tee $3 + i32.const 100000 + i32.lt_u + if (result i32) + local.get $3 + i32.const 100 + i32.lt_u + if (result i32) + local.get $3 + i32.const 10 + i32.ge_u + i32.const 1 + i32.add + else + local.get $3 + i32.const 10000 + i32.ge_u + i32.const 3 + i32.add + local.get $3 + i32.const 1000 + i32.ge_u + i32.add + end + else + local.get $3 + i32.const 10000000 + i32.lt_u + if (result i32) + local.get $3 + i32.const 1000000 + i32.ge_u + i32.const 6 + i32.add + else + local.get $3 + i32.const 1000000000 + i32.ge_u + i32.const 8 + i32.add + local.get $3 + i32.const 100000000 + i32.ge_u + i32.add + end + end + local.tee $2 + i32.const 1 + i32.shl + local.get $1 + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + local.get $0 + local.get $1 + i32.add + local.get $3 + local.get $2 + call $~lib/util/number/utoa32_dec_lut + local.get $1 + if + local.get $0 + i32.const 45 + i32.store16 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + end + local.get $0 + ) + (func $~lib/util/number/utoa64_dec_lut (param $0 i32) (param $1 i64) (param $2 i32) + (local $3 i32) + (local $4 i32) + loop $while-continue|0 + local.get $1 + i64.const 100000000 + i64.ge_u + if + local.get $0 + local.get $2 + i32.const 4 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $1 + local.get $1 + i64.const 100000000 + i64.div_u + local.tee $1 + i64.const 100000000 + i64.mul + i64.sub + i32.wrap_i64 + local.tee $3 + i32.const 10000 + i32.rem_u + local.tee $4 + i32.const 100 + i32.div_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + local.get $4 + i32.const 100 + i32.rem_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + i64.const 32 + i64.shl + i64.or + i64.store + local.get $0 + local.get $2 + i32.const 4 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $3 + i32.const 10000 + i32.div_u + local.tee $3 + i32.const 100 + i32.div_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + local.get $3 + i32.const 100 + i32.rem_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $0 + local.get $1 + i32.wrap_i64 + local.get $2 + call $~lib/util/number/utoa32_dec_lut + ) + (func $~lib/util/number/itoa_buffered (param $0 i32) (param $1 i64) (result i32) + (local $2 i32) + (local $3 i32) + local.get $0 + local.set $2 + local.get $1 + i64.const 10 + i64.lt_u + if + local.get $0 + local.get $1 + i64.const 48 + i64.or + i64.store16 + i32.const 1 + return + end + local.get $1 + i64.const 4294967295 + i64.le_u + if + local.get $1 + i32.wrap_i64 + local.tee $3 + i32.const 100000 + i32.lt_u + if (result i32) + local.get $3 + i32.const 100 + i32.lt_u + if (result i32) + local.get $3 + i32.const 10 + i32.ge_u + i32.const 1 + i32.add + else + local.get $3 + i32.const 10000 + i32.ge_u + i32.const 3 + i32.add + local.get $3 + i32.const 1000 + i32.ge_u + i32.add + end + else + local.get $3 + i32.const 10000000 + i32.lt_u + if (result i32) + local.get $3 + i32.const 1000000 + i32.ge_u + i32.const 6 + i32.add + else + local.get $3 + i32.const 1000000000 + i32.ge_u + i32.const 8 + i32.add + local.get $3 + i32.const 100000000 + i32.ge_u + i32.add + end + end + local.set $0 + local.get $2 + local.get $3 + local.get $0 + call $~lib/util/number/utoa32_dec_lut + else + local.get $2 + local.get $1 + local.get $1 + i64.const 1000000000000000 + i64.lt_u + if (result i32) + local.get $1 + i64.const 1000000000000 + i64.lt_u + if (result i32) + local.get $1 + i64.const 100000000000 + i64.ge_u + i32.const 10 + i32.add + local.get $1 + i64.const 10000000000 + i64.ge_u + i32.add + else + local.get $1 + i64.const 100000000000000 + i64.ge_u + i32.const 13 + i32.add + local.get $1 + i64.const 10000000000000 + i64.ge_u + i32.add + end + else + local.get $1 + i64.const 100000000000000000 + i64.lt_u + if (result i32) + local.get $1 + i64.const 10000000000000000 + i64.ge_u + i32.const 16 + i32.add + else + local.get $1 + i64.const -8446744073709551616 + i64.ge_u + i32.const 18 + i32.add + local.get $1 + i64.const 1000000000000000000 + i64.ge_u + i32.add + end + end + local.tee $0 + call $~lib/util/number/utoa64_dec_lut + end + local.get $0 + ) + (func $~lib/rt/itcms/__pin (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + local.get $0 + if + local.get $0 + i32.const 20 + i32.sub + local.tee $1 + i32.load offset=4 + i32.const 3 + i32.and + i32.const 3 + i32.eq + if + i32.const 20944 + i32.const 1376 + i32.const 338 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $1 + call $~lib/rt/itcms/Object#unlink + global.get $~lib/rt/itcms/pinSpace + local.tee $3 + i32.load offset=8 + local.set $2 + local.get $1 + local.get $3 + i32.const 3 + i32.or + i32.store offset=4 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $2 + local.get $1 + local.get $2 + i32.load offset=4 + i32.const 3 + i32.and + i32.or + i32.store offset=4 + local.get $3 + local.get $1 + i32.store offset=8 + end + local.get $0 + ) + (func $~lib/rt/itcms/__unpin (param $0 i32) + (local $1 i32) + (local $2 i32) + local.get $0 + i32.eqz + if + return + end + local.get $0 + i32.const 20 + i32.sub + local.tee $1 + i32.load offset=4 + i32.const 3 + i32.and + i32.const 3 + i32.ne + if + i32.const 21008 + i32.const 1376 + i32.const 352 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/state + i32.const 1 + i32.eq + if + local.get $1 + call $~lib/rt/itcms/Object#makeGray + else + local.get $1 + call $~lib/rt/itcms/Object#unlink + global.get $~lib/rt/itcms/fromSpace + local.tee $0 + i32.load offset=8 + local.set $2 + local.get $1 + local.get $0 + global.get $~lib/rt/itcms/white + i32.or + i32.store offset=4 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $2 + local.get $1 + local.get $2 + i32.load offset=4 + i32.const 3 + i32.and + i32.or + i32.store offset=4 + local.get $0 + local.get $1 + i32.store offset=8 + end + ) + (func $~lib/rt/itcms/__collect + global.get $~lib/rt/itcms/state + i32.const 0 + i32.gt_s + if + loop $while-continue|0 + global.get $~lib/rt/itcms/state + if + call $~lib/rt/itcms/step + drop + br $while-continue|0 + end + end + end + call $~lib/rt/itcms/step + drop + loop $while-continue|1 + global.get $~lib/rt/itcms/state + if + call $~lib/rt/itcms/step + drop + br $while-continue|1 + end + end + global.get $~lib/rt/itcms/total + i64.extend_i32_u + i64.const 200 + i64.mul + i64.const 100 + i64.div_u + i32.wrap_i64 + i32.const 1024 + i32.add + global.set $~lib/rt/itcms/threshold + ) + (func $assembly/gas/GasCounter#set@override (param $0 i32) (param $1 i64) + local.get $0 + i32.const 8 + i32.sub + i32.load + i32.const 51 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + unreachable + ) + (func $assembly/gas/GasCounter#sub@override (param $0 i32) (param $1 i64) (result i32) + local.get $0 + i32.const 8 + i32.sub + i32.load + i32.const 51 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i64.load + local.get $1 + i64.sub + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load + i64.const 0 + i64.lt_s + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + unreachable + ) + (func $assembly/gas/GasCounter#get@override (param $0 i32) (result i64) + (local $1 i64) + local.get $0 + i32.const 8 + i32.sub + i32.load + i32.const 51 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + unreachable + ) + (func $assembly/interpreter/Interpreter~visit (param $0 i32) + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + call $~lib/rt/itcms/__visit + ) + (func $~lib/rt/__visit_members (param $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + block $folding-inner9 + block $folding-inner8 + block $folding-inner7 + block $folding-inner6 + block $folding-inner5 + block $folding-inner4 + block $folding-inner3 + block $folding-inner2 + block $folding-inner1 + block $folding-inner0 + block $invalid + block $~lib/staticarray/StaticArray + block $assembly/interpreter/BranchResult + block $assembly/interpreter/DjumpResult + block $assembly/program/ResolvedArguments + block $assembly/gas/GasCounterU64 + block $assembly/api-generic/InitialPage + block $assembly/api-generic/VmInput + block $assembly/api-generic/VmOutput + block $assembly/codec/ValOffset + block $~lib/staticarray/StaticArray<~lib/string/String> + block $assembly/gas/GasCounter + block $~lib/staticarray/StaticArray + block $~lib/staticarray/StaticArray + block $assembly/program/Program + block $assembly/interpreter/Interpreter + block $assembly/memory/Chunks + block $~lib/staticarray/StaticArray + block $assembly/memory/Result + block $assembly/instructions/outcome/OutcomeData + block $"~lib/map/Map" + block $~lib/staticarray/StaticArray + block $assembly/memory/MaybePageFault + block $assembly/arguments/Nibbles + block $assembly/arguments/Args + block $~lib/string/String + block $~lib/arraybuffer/ArrayBuffer + block $~lib/object/Object + local.get $0 + i32.const 8 + i32.sub + i32.load + br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $folding-inner0 $folding-inner1 $folding-inner0 $assembly/arguments/Args $folding-inner2 $folding-inner3 $assembly/arguments/Nibbles $folding-inner1 $assembly/memory/MaybePageFault $folding-inner4 $folding-inner4 $~lib/staticarray/StaticArray $folding-inner5 $folding-inner0 $folding-inner2 $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $folding-inner3 $assembly/memory/Result $folding-inner6 $~lib/staticarray/StaticArray $assembly/memory/Chunks $folding-inner6 $folding-inner2 $folding-inner1 $folding-inner3 $assembly/interpreter/Interpreter $assembly/program/Program $folding-inner0 $~lib/staticarray/StaticArray $folding-inner0 $folding-inner0 $~lib/staticarray/StaticArray $assembly/gas/GasCounter $folding-inner6 $folding-inner0 $~lib/staticarray/StaticArray<~lib/string/String> $assembly/codec/ValOffset $folding-inner3 $folding-inner1 $folding-inner1 $assembly/api-generic/VmOutput $folding-inner4 $folding-inner2 $assembly/api-generic/VmInput $assembly/api-generic/InitialPage $folding-inner2 $folding-inner6 $assembly/gas/GasCounterU64 $folding-inner2 $folding-inner3 $assembly/program/ResolvedArguments $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $folding-inner2 $~lib/staticarray/StaticArray $folding-inner0 $invalid + end + return + end + return + end + return + end + return + end + return + end + return + end + return + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner7 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + local.tee $2 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=16 + i32.const 12 + i32.mul + i32.add + local.set $0 + loop $while-continue|0 + local.get $0 + local.get $1 + i32.gt_u + if + local.get $1 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if + local.get $1 + i32.load offset=4 + call $~lib/rt/itcms/__visit + end + local.get $1 + i32.const 12 + i32.add + local.set $1 + br $while-continue|0 + end + end + local.get $2 + call $~lib/rt/itcms/__visit + br $folding-inner9 + end + return + end + local.get $0 + i32.load offset=8 + call $~lib/rt/itcms/__visit + return + end + return + end + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + br $folding-inner5 + end + local.get $0 + call $assembly/interpreter/Interpreter~visit + return + end + local.get $0 + call $assembly/interpreter/Interpreter~visit + return + end + return + end + return + end + return + end + local.get $0 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.add + local.set $1 + loop $while-continue|01 + local.get $0 + local.get $1 + i32.lt_u + if + local.get $0 + i32.load + local.tee $2 + if + local.get $2 + call $~lib/rt/itcms/__visit + end + local.get $0 + i32.const 4 + i32.add + local.set $0 + br $while-continue|01 + end + end + return + end + return + end + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + call $~lib/rt/itcms/__visit + return + end + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=16 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=20 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=24 + call $~lib/rt/itcms/__visit + return + end + return + end + return + end + local.get $0 + i32.load offset=32 + call $~lib/rt/itcms/__visit + return + end + return + end + return + end + return + end + unreachable + end + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + return + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner7 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + br $folding-inner8 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner7 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.const 2 + i32.shl + i32.add + local.set $3 + loop $while-continue|00 + local.get $1 + local.get $3 + i32.lt_u + if + local.get $1 + i32.load + local.tee $2 + if + local.get $2 + call $~lib/rt/itcms/__visit + end + local.get $1 + i32.const 4 + i32.add + local.set $1 + br $while-continue|00 + end + end + br $folding-inner8 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner7 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + br $folding-inner9 + end + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + return + end + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + call $~lib/rt/itcms/__visit + return + end + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~setArgumentsLength (param $0 i32) + local.get $0 + global.set $~argumentsLength + ) + (func $~start + (local $0 i32) + memory.size + i32.const 16 + i32.shl + i32.const 54068 + i32.sub + i32.const 1 + i32.shr_u + global.set $~lib/rt/itcms/threshold + i32.const 1428 + i32.const 1424 + i32.store + i32.const 1432 + i32.const 1424 + i32.store + i32.const 1424 + global.set $~lib/rt/itcms/pinSpace + i32.const 1460 + i32.const 1456 + i32.store + i32.const 1464 + i32.const 1456 + i32.store + i32.const 1456 + global.set $~lib/rt/itcms/toSpace + i32.const 1604 + i32.const 1600 + i32.store + i32.const 1608 + i32.const 1600 + i32.store + i32.const 1600 + global.set $~lib/rt/itcms/fromSpace + call $start:assembly/instructions + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + call $assembly/memory/MaybePageFault#constructor + global.set $assembly/memory/NO_PAGE_FAULT + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + global.set $assembly/memory/EMPTY_UINT8ARRAY + i32.const -1 + i32.const 0 + call $assembly/memory-page/RawPage#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 0 + local.get $0 + call $assembly/memory-page/Page#constructor + global.set $assembly/memory/EMPTY_PAGE + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/arguments/Args#constructor (result i32) + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 6 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/arguments/Args.from (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/arguments/Args#constructor + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#get:length (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/typedarray/Uint8Array#subarray (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $4 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $4 + local.get $0 + i32.load + local.tee $5 + i32.store + local.get $4 + local.get $5 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $4 + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 0 + i32.lt_s + if (result i32) + local.get $1 + local.get $3 + i32.add + local.tee $0 + i32.const 0 + local.get $0 + i32.const 0 + i32.gt_s + select + else + local.get $1 + local.get $3 + local.get $1 + local.get $3 + i32.lt_s + select + end + local.tee $0 + i32.add + i32.store offset=4 + local.get $4 + local.get $2 + i32.const 0 + i32.lt_s + if (result i32) + local.get $2 + local.get $3 + i32.add + local.tee $1 + i32.const 0 + local.get $1 + i32.const 0 + i32.gt_s + select + else + local.get $2 + local.get $3 + local.get $2 + local.get $3 + i32.lt_s + select + end + local.tee $1 + local.get $0 + local.get $0 + local.get $1 + i32.lt_s + select + local.get $0 + i32.sub + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=8 + i32.ge_u + if + i32.const 1504 + i32.const 1744 + i32.const 167 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + i32.load8_u + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/arguments/decodeI32 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + local.get $2 + local.get $1 + local.get $1 + local.get $2 + i32.lt_u + select + call $~lib/typedarray/Uint8Array#subarray + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_u + local.set $2 + i32.const 0 + local.set $1 + loop $for-loop|0 + local.get $2 + local.get $3 + i32.gt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + local.get $3 + i32.const 3 + i32.shl + i32.shl + i32.or + local.set $1 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + i32.const 255 + i32.const 0 + local.get $2 + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $2 + i32.const 1 + i32.sub + call $~lib/typedarray/Uint8Array#__get + i32.const 128 + i32.and + else + i32.const 0 + end + select + local.set $0 + loop $for-loop|1 + local.get $2 + i32.const 4 + i32.lt_u + if + local.get $1 + local.get $0 + local.get $2 + i32.const 3 + i32.shl + i32.shl + i32.or + local.set $1 + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/arguments~anonymous|1 (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + local.get $1 + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/arguments/nibbles (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 2 + i32.const 9 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + call $~lib/object/Object#constructor + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store8 offset=1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.const 15 + i32.and + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.const 255 + i32.and + i32.const 4 + i32.shr_u + i32.store8 offset=1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/arguments/twoImm (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u + f64.convert_i32_u + f64.const 4 + f64.min + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + local.get $2 + call $assembly/arguments/decodeI32 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $2 + local.get $1 + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|2 (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + call $assembly/arguments/twoImm + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|4 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + local.get $1 + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/typedarray/Uint8Array#subarray@varargs (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $1 + end + i32.const 2147483647 + local.set $2 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $~lib/typedarray/Uint8Array#subarray + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/arguments/decodeU32 (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 2 + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 3 + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|5 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load8_u + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + local.get $0 + i32.const 1 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/arguments/decodeU32 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + local.get $0 + i32.const 5 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/arguments/decodeU32 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|6 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u offset=1 + f64.convert_i32_u + f64.const 4 + f64.min + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + local.get $3 + call $assembly/arguments/decodeI32 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + local.get $1 + call $assembly/arguments/decodeI32 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u + local.get $4 + local.get $0 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|8 (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u offset=1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|9 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load8_u offset=1 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load8_u + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + local.get $1 + call $assembly/arguments/decodeI32 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|11 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 1 + global.set $~argumentsLength + local.get $0 + i32.const 1 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.const 1 + i32.sub + i32.const 0 + local.get $1 + i32.const 1 + i32.gt_u + select + call $assembly/arguments/twoImm + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u offset=1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|12 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load8_u offset=1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load8_u + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/ensureCapacity (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=8 + local.tee $5 + local.get $2 + i32.shr_u + i32.gt_u + if + local.get $1 + i32.const 1073741820 + local.get $2 + i32.shr_u + i32.gt_u + if + i32.const 9200 + i32.const 9152 + i32.const 19 + i32.const 48 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $4 + i32.const 8 + local.get $1 + local.get $1 + i32.const 8 + i32.le_u + select + local.get $2 + i32.shl + local.set $1 + local.get $3 + if + i32.const 1073741820 + local.get $5 + i32.const 1 + i32.shl + local.tee $2 + local.get $2 + i32.const 1073741820 + i32.ge_u + select + local.tee $2 + local.get $1 + local.get $1 + local.get $2 + i32.lt_u + select + local.set $1 + end + block $__inlined_func$~lib/rt/itcms/__renew$2366 + local.get $4 + i32.const 20 + i32.sub + local.tee $3 + i32.load + i32.const -4 + i32.and + i32.const 16 + i32.sub + local.get $1 + i32.ge_u + if + local.get $3 + local.get $1 + i32.store offset=16 + local.get $4 + local.set $2 + br $__inlined_func$~lib/rt/itcms/__renew$2366 + end + local.get $1 + local.get $3 + i32.load offset=12 + call $~lib/rt/itcms/__new + local.tee $2 + local.get $4 + local.get $1 + local.get $3 + i32.load offset=16 + local.tee $3 + local.get $1 + local.get $3 + i32.lt_u + select + memory.copy + end + local.get $2 + local.get $4 + i32.ne + if + local.get $0 + local.get $2 + i32.store + local.get $0 + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + end + local.get $0 + local.get $1 + i32.store offset=8 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__set (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + local.get $1 + i32.const 0 + i32.lt_s + if + i32.const 1504 + i32.const 9152 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + i32.store offset=12 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 2320 + i32.store + i32.const 2320 + i32.const 0 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/MISSING_INSTRUCTION + global.get $~lib/memory/__stack_pointer + i32.const 2368 + i32.store + i32.const 2368 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/SBRK + global.get $~lib/memory/__stack_pointer + i32.const 231 + i32.const 2 + i32.const 10 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 2400 + i32.store + local.get $0 + i32.const 0 + i32.const 2400 + i32.const 0 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2432 + i32.store + local.get $0 + i32.const 1 + i32.const 2432 + i32.const 0 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 5 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 6 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 7 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 8 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 9 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2480 + i32.store + local.get $0 + i32.const 10 + i32.const 2480 + i32.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 11 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 12 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 13 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 14 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 15 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 16 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 17 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 18 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 19 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2512 + i32.store + local.get $0 + i32.const 20 + i32.const 2512 + i32.const 5 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 21 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 22 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 23 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 24 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 25 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 26 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 27 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 28 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 29 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2560 + i32.store + local.get $0 + i32.const 30 + i32.const 2560 + i32.const 2 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2608 + i32.store + local.get $0 + i32.const 31 + i32.const 2608 + i32.const 2 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2656 + i32.store + local.get $0 + i32.const 32 + i32.const 2656 + i32.const 2 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2704 + i32.store + local.get $0 + i32.const 33 + i32.const 2704 + i32.const 2 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 34 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 35 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 36 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 37 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 38 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 39 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2752 + i32.store + local.get $0 + i32.const 40 + i32.const 2752 + i32.const 3 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 41 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 42 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 43 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 44 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 45 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 46 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 47 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 48 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 49 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2784 + i32.store + local.get $0 + i32.const 50 + i32.const 2784 + i32.const 4 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2832 + i32.store + local.get $0 + i32.const 51 + i32.const 2832 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2880 + i32.store + local.get $0 + i32.const 52 + i32.const 2880 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2928 + i32.store + local.get $0 + i32.const 53 + i32.const 2928 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2976 + i32.store + local.get $0 + i32.const 54 + i32.const 2976 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3024 + i32.store + local.get $0 + i32.const 55 + i32.const 3024 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3072 + i32.store + local.get $0 + i32.const 56 + i32.const 3072 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3120 + i32.store + local.get $0 + i32.const 57 + i32.const 3120 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3168 + i32.store + local.get $0 + i32.const 58 + i32.const 3168 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3216 + i32.store + local.get $0 + i32.const 59 + i32.const 3216 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3264 + i32.store + local.get $0 + i32.const 60 + i32.const 3264 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3312 + i32.store + local.get $0 + i32.const 61 + i32.const 3312 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3360 + i32.store + local.get $0 + i32.const 62 + i32.const 3360 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 63 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 64 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 65 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 66 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 67 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 68 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 69 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3408 + i32.store + local.get $0 + i32.const 70 + i32.const 3408 + i32.const 6 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3472 + i32.store + local.get $0 + i32.const 71 + i32.const 3472 + i32.const 6 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3536 + i32.store + local.get $0 + i32.const 72 + i32.const 3536 + i32.const 6 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3600 + i32.store + local.get $0 + i32.const 73 + i32.const 3600 + i32.const 6 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 74 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 75 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 76 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 77 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 78 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 79 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3664 + i32.store + local.get $0 + i32.const 80 + i32.const 3664 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3712 + i32.store + local.get $0 + i32.const 81 + i32.const 3712 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3760 + i32.store + local.get $0 + i32.const 82 + i32.const 3760 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3808 + i32.store + local.get $0 + i32.const 83 + i32.const 3808 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3872 + i32.store + local.get $0 + i32.const 84 + i32.const 3872 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3936 + i32.store + local.get $0 + i32.const 85 + i32.const 3936 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4000 + i32.store + local.get $0 + i32.const 86 + i32.const 4000 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4064 + i32.store + local.get $0 + i32.const 87 + i32.const 4064 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4128 + i32.store + local.get $0 + i32.const 88 + i32.const 4128 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4192 + i32.store + local.get $0 + i32.const 89 + i32.const 4192 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4256 + i32.store + local.get $0 + i32.const 90 + i32.const 4256 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 91 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 92 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 93 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 94 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 95 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 96 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 97 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 98 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 99 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4320 + i32.store + local.get $0 + i32.const 100 + i32.const 4320 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 101 + global.get $assembly/instructions/SBRK + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4368 + i32.store + local.get $0 + i32.const 102 + i32.const 4368 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4432 + i32.store + local.get $0 + i32.const 103 + i32.const 4432 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4496 + i32.store + local.get $0 + i32.const 104 + i32.const 4496 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4560 + i32.store + local.get $0 + i32.const 105 + i32.const 4560 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4624 + i32.store + local.get $0 + i32.const 106 + i32.const 4624 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4688 + i32.store + local.get $0 + i32.const 107 + i32.const 4688 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4752 + i32.store + local.get $0 + i32.const 108 + i32.const 4752 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4800 + i32.store + local.get $0 + i32.const 109 + i32.const 4800 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4848 + i32.store + local.get $0 + i32.const 110 + i32.const 4848 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4896 + i32.store + local.get $0 + i32.const 111 + i32.const 4896 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 112 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 113 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 114 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 115 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 116 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 117 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 118 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 119 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4944 + i32.store + local.get $0 + i32.const 120 + i32.const 4944 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4992 + i32.store + local.get $0 + i32.const 121 + i32.const 4992 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5040 + i32.store + local.get $0 + i32.const 122 + i32.const 5040 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5088 + i32.store + local.get $0 + i32.const 123 + i32.const 5088 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5136 + i32.store + local.get $0 + i32.const 124 + i32.const 5136 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5184 + i32.store + local.get $0 + i32.const 125 + i32.const 5184 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5232 + i32.store + local.get $0 + i32.const 126 + i32.const 5232 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5280 + i32.store + local.get $0 + i32.const 127 + i32.const 5280 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5328 + i32.store + local.get $0 + i32.const 128 + i32.const 5328 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5376 + i32.store + local.get $0 + i32.const 129 + i32.const 5376 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5424 + i32.store + local.get $0 + i32.const 130 + i32.const 5424 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5472 + i32.store + local.get $0 + i32.const 131 + i32.const 5472 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5520 + i32.store + local.get $0 + i32.const 132 + i32.const 5520 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5568 + i32.store + local.get $0 + i32.const 133 + i32.const 5568 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5616 + i32.store + local.get $0 + i32.const 134 + i32.const 5616 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5648 + i32.store + local.get $0 + i32.const 135 + i32.const 5648 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5696 + i32.store + local.get $0 + i32.const 136 + i32.const 5696 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5744 + i32.store + local.get $0 + i32.const 137 + i32.const 5744 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5792 + i32.store + local.get $0 + i32.const 138 + i32.const 5792 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5840 + i32.store + local.get $0 + i32.const 139 + i32.const 5840 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5888 + i32.store + local.get $0 + i32.const 140 + i32.const 5888 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5936 + i32.store + local.get $0 + i32.const 141 + i32.const 5936 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5984 + i32.store + local.get $0 + i32.const 142 + i32.const 5984 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6032 + i32.store + local.get $0 + i32.const 143 + i32.const 6032 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6080 + i32.store + local.get $0 + i32.const 144 + i32.const 6080 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6144 + i32.store + local.get $0 + i32.const 145 + i32.const 6144 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6208 + i32.store + local.get $0 + i32.const 146 + i32.const 6208 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6272 + i32.store + local.get $0 + i32.const 147 + i32.const 6272 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6320 + i32.store + local.get $0 + i32.const 148 + i32.const 6320 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6368 + i32.store + local.get $0 + i32.const 149 + i32.const 6368 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6416 + i32.store + local.get $0 + i32.const 150 + i32.const 6416 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6464 + i32.store + local.get $0 + i32.const 151 + i32.const 6464 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6512 + i32.store + local.get $0 + i32.const 152 + i32.const 6512 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6560 + i32.store + local.get $0 + i32.const 153 + i32.const 6560 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6608 + i32.store + local.get $0 + i32.const 154 + i32.const 6608 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6656 + i32.store + local.get $0 + i32.const 155 + i32.const 6656 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6720 + i32.store + local.get $0 + i32.const 156 + i32.const 6720 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6784 + i32.store + local.get $0 + i32.const 157 + i32.const 6784 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6848 + i32.store + local.get $0 + i32.const 158 + i32.const 6848 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6896 + i32.store + local.get $0 + i32.const 159 + i32.const 6896 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6960 + i32.store + local.get $0 + i32.const 160 + i32.const 6960 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7008 + i32.store + local.get $0 + i32.const 161 + i32.const 7008 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 162 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 163 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 164 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 165 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 166 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 167 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 168 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 169 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7072 + i32.store + local.get $0 + i32.const 170 + i32.const 7072 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7120 + i32.store + local.get $0 + i32.const 171 + i32.const 7120 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7168 + i32.store + local.get $0 + i32.const 172 + i32.const 7168 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7216 + i32.store + local.get $0 + i32.const 173 + i32.const 7216 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7264 + i32.store + local.get $0 + i32.const 174 + i32.const 7264 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7312 + i32.store + local.get $0 + i32.const 175 + i32.const 7312 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 176 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 177 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 178 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 179 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7360 + i32.store + local.get $0 + i32.const 180 + i32.const 7360 + i32.const 11 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 181 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 182 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 183 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 184 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 185 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 186 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 187 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 188 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 189 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7424 + i32.store + local.get $0 + i32.const 190 + i32.const 7424 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7456 + i32.store + local.get $0 + i32.const 191 + i32.const 7456 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7488 + i32.store + local.get $0 + i32.const 192 + i32.const 7488 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7520 + i32.store + local.get $0 + i32.const 193 + i32.const 7520 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7568 + i32.store + local.get $0 + i32.const 194 + i32.const 7568 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7616 + i32.store + local.get $0 + i32.const 195 + i32.const 7616 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7664 + i32.store + local.get $0 + i32.const 196 + i32.const 7664 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7712 + i32.store + local.get $0 + i32.const 197 + i32.const 7712 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7760 + i32.store + local.get $0 + i32.const 198 + i32.const 7760 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7808 + i32.store + local.get $0 + i32.const 199 + i32.const 7808 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7856 + i32.store + local.get $0 + i32.const 200 + i32.const 7856 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7888 + i32.store + local.get $0 + i32.const 201 + i32.const 7888 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7920 + i32.store + local.get $0 + i32.const 202 + i32.const 7920 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7952 + i32.store + local.get $0 + i32.const 203 + i32.const 7952 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8000 + i32.store + local.get $0 + i32.const 204 + i32.const 8000 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8048 + i32.store + local.get $0 + i32.const 205 + i32.const 8048 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8096 + i32.store + local.get $0 + i32.const 206 + i32.const 8096 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8144 + i32.store + local.get $0 + i32.const 207 + i32.const 8144 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8192 + i32.store + local.get $0 + i32.const 208 + i32.const 8192 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8240 + i32.store + local.get $0 + i32.const 209 + i32.const 8240 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8288 + i32.store + local.get $0 + i32.const 210 + i32.const 8288 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8320 + i32.store + local.get $0 + i32.const 211 + i32.const 8320 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8352 + i32.store + local.get $0 + i32.const 212 + i32.const 8352 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8384 + i32.store + local.get $0 + i32.const 213 + i32.const 8384 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8432 + i32.store + local.get $0 + i32.const 214 + i32.const 8432 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8480 + i32.store + local.get $0 + i32.const 215 + i32.const 8480 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8528 + i32.store + local.get $0 + i32.const 216 + i32.const 8528 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8576 + i32.store + local.get $0 + i32.const 217 + i32.const 8576 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8624 + i32.store + local.get $0 + i32.const 218 + i32.const 8624 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8672 + i32.store + local.get $0 + i32.const 219 + i32.const 8672 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8720 + i32.store + local.get $0 + i32.const 220 + i32.const 8720 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8768 + i32.store + local.get $0 + i32.const 221 + i32.const 8768 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8816 + i32.store + local.get $0 + i32.const 222 + i32.const 8816 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8864 + i32.store + local.get $0 + i32.const 223 + i32.const 8864 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8912 + i32.store + local.get $0 + i32.const 224 + i32.const 8912 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8960 + i32.store + local.get $0 + i32.const 225 + i32.const 8960 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8992 + i32.store + local.get $0 + i32.const 226 + i32.const 8992 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 9024 + i32.store + local.get $0 + i32.const 227 + i32.const 9024 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 9056 + i32.store + local.get $0 + i32.const 228 + i32.const 9056 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 9088 + i32.store + local.get $0 + i32.const 229 + i32.const 9088 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 9120 + i32.store + local.get $0 + i32.const 230 + i32.const 9120 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/INSTRUCTIONS + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/MaybePageFault#constructor (result i32) + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 11 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store8 offset=1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/typedarray/Uint8Array#constructor (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $1 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 3 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store + local.get $1 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=8 + local.get $0 + i32.const 1073741820 + i32.gt_u + if + i32.const 9200 + i32.const 9248 + i32.const 19 + i32.const 57 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.store + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory-page/Page#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 12 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $2 + local.get $1 + i32.store offset=4 + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/memory-page/RawPage#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 13 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $2 + local.get $1 + i32.store offset=4 + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i64) + (local $2 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 3 + i32.shl + i32.add + i64.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.const 3 + i32.shl + i32.add + local.get $2 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/OutcomeData#constructor (result i32) + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.const 19 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $start:assembly/instructions/bit~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.popcnt + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.popcnt + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.clz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.clz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.ctz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.ctz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.extend8_s + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.extend16_s + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.const 65535 + i32.and + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.tee $3 + i64.const 8 + i64.shr_u + i64.const 71777214294589695 + i64.and + local.get $3 + i64.const 71777214294589695 + i64.and + i64.const 8 + i64.shl + i64.or + local.tee $3 + i64.const 16 + i64.shr_u + i64.const 281470681808895 + i64.and + local.get $3 + i64.const 281470681808895 + i64.and + i64.const 16 + i64.shl + i64.or + i64.const 32 + i64.rotr + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/staticJump (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/branch~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.ne + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.gt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.ge_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.ne + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.gt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/jump~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/dJump (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/jump~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.add + i32.wrap_i64 + call $assembly/instructions/outcome/dJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/jump~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=4 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/jump~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=12 + i64.add + i32.wrap_i64 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/dJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_u offset=8 + i64.const 32 + i64.shl + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=4 + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Chunks#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 24 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $3 + local.get $0 + i32.store + local.get $3 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + i32.store offset=4 + local.get $3 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $3 + local.get $2 + i32.store offset=8 + local.get $3 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory/Chunks#constructor@varargs (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $1 + i32.store + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $2 + i32.store offset=4 + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=20 + local.get $0 + local.get $1 + local.get $2 + call $assembly/memory/Chunks#constructor + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#find" (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.load offset=4 + i32.and + i32.const 2 + i32.shl + i32.add + i32.load + local.set $0 + loop $while-continue|0 + local.get $0 + if + local.get $0 + i32.load offset=8 + local.tee $2 + i32.const 1 + i32.and + if (result i32) + i32.const 0 + else + local.get $1 + local.get $0 + i32.load + i32.eq + end + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + local.get $2 + i32.const -2 + i32.and + local.set $0 + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $"~lib/map/Map#has" (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $1 + i32.const -1028477379 + i32.mul + i32.const 374761397 + i32.add + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.tee $0 + local.get $0 + i32.const 15 + i32.shr_u + i32.xor + i32.const -2048144777 + i32.mul + local.tee $0 + local.get $0 + i32.const 13 + i32.shr_u + i32.xor + i32.const -1028477379 + i32.mul + local.tee $0 + local.get $0 + i32.const 16 + i32.shr_u + i32.xor + call $"~lib/map/Map#find" + i32.const 0 + i32.ne + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/PageData#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 25 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $3 + local.get $0 + i32.store + local.get $3 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + i32.store offset=4 + local.get $3 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory/fault (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/memory/MaybePageFault#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 1 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $"~lib/map/Map#get" (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $1 + i32.const -1028477379 + i32.mul + i32.const 374761397 + i32.add + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.tee $0 + local.get $0 + i32.const 15 + i32.shr_u + i32.xor + i32.const -2048144777 + i32.mul + local.tee $0 + local.get $0 + i32.const 13 + i32.shr_u + i32.xor + i32.const -1028477379 + i32.mul + local.tee $0 + local.get $0 + i32.const 16 + i32.shr_u + i32.xor + call $"~lib/map/Map#find" + local.tee $0 + i32.eqz + if + i32.const 10400 + i32.const 10464 + i32.const 105 + i32.const 17 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory-page/Page#can (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + i32.const 2 + i32.eq + if (result i32) + i32.const 1 + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load + i32.eq + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/typedarray/Uint8Array#fill@varargs (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $1of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 2147483647 + local.set $1 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.tee $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.le_s + select + local.tee $3 + local.get $1 + local.get $2 + local.get $1 + local.get $2 + i32.lt_s + select + local.tee $1 + i32.lt_s + if + local.get $3 + local.get $4 + i32.add + i32.const 0 + local.get $1 + local.get $3 + i32.sub + memory.fill + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory-page/RawPage#get:data (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 4096 + call $~lib/typedarray/Uint8Array#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + i32.const 1 + global.set $~argumentsLength + local.get $1 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 10640 + i32.const 42 + i32.const 12 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/memory/Memory#getChunks (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner3 (result i32) + block $folding-inner2 + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + local.get $3 + i32.const 255 + i32.and + i32.eqz + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $0 + i32.store + br $folding-inner2 + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $2 + i32.const 4095 + i32.and + local.set $5 + local.get $2 + i32.const 12 + i32.shr_u + local.tee $6 + i32.const 12 + i32.shl + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $8 + i32.store + block $__inlined_func$assembly/memory/Memory#getPage$2371 (result i32) + local.get $8 + local.get $6 + call $"~lib/map/Map#has" + i32.eqz + if + local.get $7 + call $assembly/memory/fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_PAGE + local.tee $7 + i32.store offset=4 + local.get $6 + local.get $7 + local.get $5 + call $assembly/memory/PageData#constructor + br $__inlined_func$assembly/memory/Memory#getPage$2371 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $8 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + local.get $6 + call $"~lib/map/Map#get" + local.tee $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $1 + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $7 + call $assembly/memory/fault + local.tee $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 1 + i32.store8 offset=1 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_PAGE + local.tee $7 + i32.store offset=4 + local.get $6 + local.get $7 + local.get $5 + call $assembly/memory/PageData#constructor + br $__inlined_func$assembly/memory/Memory#getPage$2371 + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $7 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $7 + local.get $6 + local.get $5 + call $assembly/memory/PageData#constructor + end + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $4 + i32.store + local.get $4 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $0 + i32.store + br $folding-inner2 + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + local.tee $4 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.load offset=8 + local.tee $5 + local.get $3 + i32.const 255 + i32.and + i32.add + local.tee $6 + i32.const 4096 + i32.le_u + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load offset=4 + local.tee $1 + i32.store offset=8 + local.get $1 + call $assembly/memory-page/RawPage#get:data + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $5 + local.get $6 + call $~lib/typedarray/Uint8Array#subarray + local.tee $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 2 + global.set $~argumentsLength + local.get $1 + local.get $0 + call $assembly/memory/Chunks#constructor@varargs + br $folding-inner3 + end + local.get $2 + local.get $3 + i32.const 255 + i32.and + i32.add + i64.extend_i32_u + i64.const 4294967295 + i64.and + i32.wrap_i64 + i32.const 12 + i32.shr_u + local.tee $2 + i32.const 12 + i32.shl + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $7 + i32.store + block $folding-inner0 + local.get $7 + local.get $2 + call $"~lib/map/Map#has" + i32.eqz + if + local.get $6 + call $assembly/memory/fault + local.set $0 + br $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $2 + call $"~lib/map/Map#get" + local.tee $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $6 + call $assembly/memory/fault + local.tee $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store8 offset=1 + br $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load offset=4 + local.tee $2 + i32.store offset=8 + local.get $2 + call $assembly/memory-page/RawPage#get:data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + i32.const 1 + global.set $~argumentsLength + local.get $2 + local.get $5 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $1 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=8 + local.get $0 + call $assembly/memory-page/RawPage#get:data + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + local.get $5 + local.get $3 + i32.const 255 + i32.and + i32.add + i32.const 4096 + i32.sub + call $~lib/typedarray/Uint8Array#subarray + local.tee $0 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + local.get $2 + local.get $1 + local.get $0 + call $assembly/memory/Chunks#constructor + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + br $folding-inner2 + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + i32.const 1 + global.set $~argumentsLength + local.get $0 + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + end + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/ChunkBytes#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 22 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $2 + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $2 + local.get $1 + i32.store offset=4 + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.add + local.get $2 + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getBytes (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 1 + local.get $1 + local.get $2 + call $assembly/memory/Memory#getChunks + local.tee $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $0 + i32.store + local.get $0 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $0 + i32.store + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $~lib/staticarray/StaticArray#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $0 + local.get $1 + call $assembly/memory/ChunkBytes#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=8 + local.tee $4 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.const 255 + i32.and + call $~lib/staticarray/StaticArray#constructor + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $6 + loop $for-loop|0 + local.get $3 + local.get $6 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $2 + local.get $3 + local.get $0 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + i32.const 0 + local.set $0 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $2 + local.get $0 + local.get $6 + i32.add + local.get $4 + local.get $0 + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $0 + i32.const 1 + i32.add + local.set $0 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $0 + local.get $2 + call $assembly/memory/ChunkBytes#constructor + local.set $0 + br $folding-inner1 + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/memory/Result#constructor (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 21 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + call $assembly/memory/MaybePageFault#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.add + i32.load8_u + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getU8 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/instructions/outcome/okOrFault (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 2 + i32.const 1 + local.get $0 + i32.load8_u offset=1 + select + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.load offset=4 + i32.store offset=16 + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getU8 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getI8 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i32.extend8_s + i64.extend_i32_s + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getI8 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getU16 (param $0 i32) (param $1 i32) (result i32) + (local $2 i64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.store offset=8 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + local.get $3 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $0 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getU16 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getI16 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store + local.get $2 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i32.or + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $0 + i32.extend16_s + i64.extend_i32_s + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getI16 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getU32 (param $0 i32) (param $1 i32) (result i32) + (local $2 i64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.store offset=8 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + local.get $3 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i64.extend_i32_u + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $0 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i64.extend_i32_u + i64.or + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getU32 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getI32 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store + local.get $2 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store + local.get $3 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store + local.get $3 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i32.or + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $0 + i64.extend_i32_s + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getI32 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getU64 (param $0 i32) (param $1 i32) (result i32) + (local $2 i64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 8 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.store offset=8 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + local.get $3 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 8 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 16 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 24 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 4 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 32 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 5 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 40 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 6 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 48 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $0 + i32.const 7 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 56 + i64.shl + i64.or + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getU64 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getU8 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getI8 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getU16 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getI16 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getU32 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getI32 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getU64 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.xor + i64.const -1 + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $3 + local.get $5 + i64.add + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_u offset=8 + i64.mul + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_u offset=8 + i64.const 4294967296 + i64.or + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + local.get $4 + i32.add + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 4294967296 + i64.add + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + i64.sub + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.mul + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.tee $2 + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.div_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const -1 + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.extend32_s + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.extend32_s + local.tee $4 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const -1 + call $~lib/staticarray/StaticArray#__set + else + local.get $3 + i64.const -2147483648 + i64.eq + local.get $4 + i64.const -1 + i64.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $3 + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $3 + local.get $4 + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + local.get $2 + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.rem_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.tee $4 + if + local.get $2 + i32.const -2147483648 + i32.eq + local.get $4 + i32.const -1 + i32.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_s + local.get $4 + i64.extend_i32_s + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.sub + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const -1 + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.div_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|17 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.tee $4 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const -1 + call $~lib/staticarray/StaticArray#__set + else + local.get $3 + i64.const -9223372036854775808 + i64.eq + local.get $4 + i64.const -1 + i64.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $3 + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $3 + local.get $4 + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|18 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.rem_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|19 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.tee $4 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $3 + call $~lib/staticarray/StaticArray#__set + else + local.get $3 + i64.const -9223372036854775808 + i64.eq + local.get $4 + i64.const -1 + i64.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $3 + local.get $4 + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|20 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i64) + (local $10 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + block $__inlined_func$assembly/instructions/utils/mulUpperSigned$4 (result i64) + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + local.get $4 + i64.const 0 + i64.lt_s + if (result i32) + local.get $4 + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $4 + i32.const 1 + else + i32.const 0 + end + local.set $0 + local.get $3 + i64.const 0 + i64.lt_s + if (result i32) + local.get $3 + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $3 + local.get $0 + i32.eqz + else + local.get $0 + end + if + local.get $3 + i64.const 32 + i64.shr_u + local.tee $8 + local.get $4 + i64.const 4294967295 + i64.and + local.tee $5 + i64.mul + local.set $6 + local.get $4 + i64.const 32 + i64.shr_u + local.tee $7 + local.get $3 + i64.const 4294967295 + i64.and + local.tee $9 + i64.mul + local.set $10 + local.get $3 + local.get $4 + i64.mul + i64.eqz + i64.extend_i32_u + local.get $7 + local.get $8 + i64.mul + local.get $6 + i64.const 32 + i64.shr_u + i64.add + local.get $10 + i64.const 32 + i64.shr_u + i64.add + local.get $6 + i64.const 4294967295 + i64.and + local.get $5 + local.get $9 + i64.mul + i64.const 32 + i64.shr_u + i64.add + local.get $10 + i64.const 4294967295 + i64.and + i64.add + i64.const 32 + i64.shr_u + i64.add + i64.const -1 + i64.xor + i64.add + br $__inlined_func$assembly/instructions/utils/mulUpperSigned$4 + end + local.get $3 + i64.const 32 + i64.shr_u + local.tee $5 + local.get $4 + i64.const 4294967295 + i64.and + local.tee $6 + i64.mul + local.set $7 + local.get $4 + i64.const 32 + i64.shr_u + local.tee $4 + local.get $5 + i64.mul + local.get $7 + i64.const 32 + i64.shr_u + i64.add + local.get $3 + i64.const 4294967295 + i64.and + local.tee $3 + local.get $4 + i64.mul + local.tee $4 + i64.const 32 + i64.shr_u + i64.add + local.get $7 + i64.const 4294967295 + i64.and + local.get $3 + local.get $6 + i64.mul + i64.const 32 + i64.shr_u + i64.add + local.get $4 + i64.const 4294967295 + i64.and + i64.add + i64.const 32 + i64.shr_u + i64.add + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|21 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.tee $5 + i64.const 32 + i64.shr_u + local.set $6 + local.get $4 + i64.const 32 + i64.shr_u + local.tee $7 + local.get $5 + i64.const 4294967295 + i64.and + local.tee $5 + i64.mul + local.set $8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $6 + local.get $7 + i64.mul + local.get $4 + i64.const 4294967295 + i64.and + local.tee $3 + local.get $6 + i64.mul + local.tee $4 + i64.const 32 + i64.shr_u + i64.add + local.get $8 + i64.const 32 + i64.shr_u + i64.add + local.get $4 + i64.const 4294967295 + i64.and + local.get $3 + local.get $5 + i64.mul + i64.const 32 + i64.shr_u + i64.add + local.get $8 + i64.const 4294967295 + i64.and + i64.add + i64.const 32 + i64.shr_u + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|22 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i64) + (local $10 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2376 (result i64) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $5 + local.get $3 + i64.const 0 + i64.lt_s + if + local.get $3 + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.tee $6 + i64.const 4294967295 + i64.and + local.tee $7 + local.get $5 + i64.const 32 + i64.shr_u + local.tee $8 + i64.mul + local.set $3 + local.get $6 + i64.const 32 + i64.shr_u + local.tee $4 + local.get $5 + i64.const 4294967295 + i64.and + local.tee $9 + i64.mul + local.set $10 + local.get $5 + local.get $6 + i64.mul + i64.eqz + i64.extend_i32_u + local.get $4 + local.get $8 + i64.mul + local.get $3 + i64.const 32 + i64.shr_u + i64.add + local.get $10 + i64.const 32 + i64.shr_u + i64.add + local.get $3 + i64.const 4294967295 + i64.and + local.get $7 + local.get $9 + i64.mul + i64.const 32 + i64.shr_u + i64.add + local.get $10 + i64.const 4294967295 + i64.and + i64.add + i64.const 32 + i64.shr_u + i64.add + i64.const -1 + i64.xor + i64.add + br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2376 + end + local.get $3 + i64.const 4294967295 + i64.and + local.tee $4 + local.get $5 + i64.const 32 + i64.shr_u + local.tee $6 + i64.mul + local.set $7 + local.get $3 + i64.const 32 + i64.shr_u + local.tee $3 + local.get $5 + i64.const 4294967295 + i64.and + local.tee $5 + i64.mul + local.set $8 + local.get $3 + local.get $6 + i64.mul + local.get $7 + i64.const 32 + i64.shr_u + i64.add + local.get $8 + i64.const 32 + i64.shr_u + i64.add + local.get $7 + i64.const 4294967295 + i64.and + local.get $4 + local.get $5 + i64.mul + i64.const 32 + i64.shr_u + i64.add + local.get $8 + i64.const 4294967295 + i64.and + i64.add + i64.const 32 + i64.shr_u + i64.add + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|23 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $3 + local.get $3 + local.get $4 + i64.lt_s + select + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|24 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $3 + local.get $3 + local.get $4 + i64.lt_u + select + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|25 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $3 + local.get $3 + local.get $4 + i64.gt_s + select + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|26 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $3 + local.get $3 + local.get $4 + i64.gt_u + select + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.rotr + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_s offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.rotr + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + local.get $0 + i32.load offset=8 + i32.rotr + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=8 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.rotr + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.rotl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $2 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.rotl + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.rotr + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $2 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.rotr + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.lt_u + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.lt_s + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.gt_u + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.gt_s + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.gt_u + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.gt_s + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 31 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.shl + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 31 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.shr_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 31 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.extend32_s + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i32.load offset=8 + local.get $2 + i32.shl + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i32.load offset=8 + local.get $2 + i32.shr_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 63 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $2 + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 63 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $2 + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 63 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + local.get $2 + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + local.get $2 + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.shl + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.shr_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.extend32_s + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $2 + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $2 + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|17 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $2 + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/typedarray/Uint8Array#__set (param $0 i32) (param $1 i32) (param $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=8 + i32.ge_u + if + i32.const 1504 + i32.const 1744 + i32.const 178 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + local.get $2 + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 2 + local.get $1 + i32.const 1 + call $assembly/memory/Memory#getChunks + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + local.get $1 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $1 + i32.store + local.get $1 + i32.const 0 + local.get $2 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=4 + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 2 + local.get $1 + i32.const 2 + call $assembly/memory/Memory#getChunks + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + local.get $1 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $1 + i32.store + local.get $1 + i32.const 0 + local.get $2 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $1 + i32.store + local.get $1 + i32.const 1 + local.get $2 + i32.const 65535 + i32.and + i32.const 8 + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $1 + i32.store + local.get $1 + i32.const 0 + local.get $2 + i32.const 65535 + i32.and + i32.const 8 + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=4 + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU32 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 2 + local.get $1 + i32.const 4 + call $assembly/memory/Memory#getChunks + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $0 + i32.store + local.get $0 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $4 + loop $for-loop|0 + local.get $3 + local.get $4 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + local.get $3 + local.get $2 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 8 + i32.shr_u + local.set $2 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + i32.const 0 + local.set $3 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $3 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + local.get $3 + local.get $2 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 8 + i32.shr_u + local.set $2 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#setU32 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU64 (param $0 i32) (param $1 i32) (param $2 i64) (result i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 2 + local.get $1 + i32.const 8 + call $assembly/memory/Memory#getChunks + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $0 + i32.store + local.get $0 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $4 + loop $for-loop|0 + local.get $3 + local.get $4 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + local.get $3 + local.get $2 + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i64.const 8 + i64.shr_u + local.set $2 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + i32.const 0 + local.set $3 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $3 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + local.get $3 + local.get $2 + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i64.const 8 + i64.shr_u + local.set $2 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i64.load32_s offset=4 + call $assembly/memory/Memory#setU64 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.add + i32.wrap_i64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=8 + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.add + i32.wrap_i64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=8 + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.add + i32.wrap_i64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=8 + call $assembly/memory/Memory#setU32 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.add + i32.wrap_i64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i64.load32_s offset=8 + call $assembly/memory/Memory#setU64 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/misc~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $1 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/array/Array#get:length (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/console/console.log (param $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/bindings/dom/console.log + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory-page/Arena#acquire (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length + i32.const 0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load offset=12 + local.tee $0 + i32.const 0 + i32.le_s + if + i32.const 14144 + i32.const 9152 + i32.const 271 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.get $0 + i32.const 1 + i32.sub + local.tee $0 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 12 + i32.shl + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 14192 + i32.store + i32.const 14192 + call $~lib/console/console.log + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 536870912 + i32.lt_u + if (result i32) + i32.const 4096 + call $~lib/typedarray/Uint8Array#constructor + else + i32.const 0 + end + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=8 + i32.const 1 + i32.add + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/memory-page/RawPage#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $"~lib/map/Map#set" (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $1 + i32.const -1028477379 + i32.mul + i32.const 374761397 + i32.add + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.tee $3 + local.get $3 + i32.const 15 + i32.shr_u + i32.xor + i32.const -2048144777 + i32.mul + local.tee $3 + local.get $3 + i32.const 13 + i32.shr_u + i32.xor + i32.const -1028477379 + i32.mul + local.tee $3 + local.get $3 + i32.const 16 + i32.shr_u + i32.xor + local.tee $8 + call $"~lib/map/Map#find" + local.tee $3 + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $3 + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=12 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=12 + i32.const 3 + i32.mul + i32.const 4 + i32.div_s + i32.lt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + i32.const 1 + i32.shl + i32.const 1 + i32.or + end + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.shl + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $10 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.const 3 + i32.shl + i32.const 3 + i32.div_s + local.tee $7 + i32.const 12 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=8 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $11 + local.get $0 + i32.load offset=16 + i32.const 12 + i32.mul + i32.add + local.set $6 + local.get $4 + local.set $3 + loop $while-continue|0 + local.get $6 + local.get $11 + i32.ne + if + local.get $11 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if + local.get $3 + local.get $11 + i32.load + local.tee $12 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=4 + local.tee $5 + i32.store offset=8 + local.get $3 + local.get $5 + i32.store offset=4 + local.get $3 + local.get $10 + local.get $9 + local.get $12 + i32.const -1028477379 + i32.mul + i32.const 374761397 + i32.add + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.tee $5 + i32.const 15 + i32.shr_u + local.get $5 + i32.xor + i32.const -2048144777 + i32.mul + local.tee $5 + i32.const 13 + i32.shr_u + local.get $5 + i32.xor + i32.const -1028477379 + i32.mul + local.tee $5 + i32.const 16 + i32.shr_u + local.get $5 + i32.xor + i32.and + i32.const 2 + i32.shl + i32.add + local.tee $5 + i32.load + i32.store offset=8 + local.get $5 + local.get $3 + i32.store + local.get $3 + i32.const 12 + i32.add + local.set $3 + end + local.get $11 + i32.const 12 + i32.add + local.set $11 + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $0 + local.get $10 + i32.store + local.get $0 + local.get $10 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $0 + local.get $4 + i32.store offset=8 + local.get $0 + local.get $4 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + local.get $7 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $0 + local.get $0 + i32.load offset=20 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=16 + local.tee $4 + i32.const 1 + i32.add + i32.store offset=16 + local.get $3 + local.get $4 + i32.const 12 + i32.mul + i32.add + local.tee $3 + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $3 + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=20 + i32.const 1 + i32.add + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $3 + local.get $1 + local.get $8 + local.get $0 + i32.load offset=4 + i32.and + i32.const 2 + i32.shl + i32.add + local.tee $0 + i32.load + i32.store offset=8 + local.get $0 + local.get $3 + i32.store + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $start:assembly/instructions/misc~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $6 + local.get $2 + i64.load32_u offset=12 + i64.store + block $folding-inner0 + local.get $4 + i32.eqz + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i64.load32_u offset=12 + local.get $4 + i64.extend_i32_u + i64.add + local.tee $3 + i64.const 4294967296 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=8 + local.tee $2 + i32.store offset=4 + local.get $2 + i32.const 1 + i32.store8 + br $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $3 + i64.store32 offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $3 + i64.const 1 + i64.sub + i64.const 12 + i64.shr_s + i32.wrap_i64 + local.tee $5 + local.get $2 + i32.load + i32.eq + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.load + i32.const 1 + i32.add + local.set $4 + loop $for-loop|0 + local.get $4 + local.get $5 + i32.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + local.tee $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + call $assembly/memory-page/Arena#acquire + local.tee $7 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + i32.const 2 + local.get $7 + call $assembly/memory-page/Page#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $8 + local.get $4 + local.get $7 + call $"~lib/map/Map#set" + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $5 + i32.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + i32.load8_u + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/codec~anonymous|0 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15344 + i32.store + i32.const 15344 + call $~lib/array/Array#get:length + local.set $2 + loop $for-loop|0 + local.get $1 + local.get $2 + i32.const 255 + i32.and + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + i32.const 15344 + i32.store + i32.const 15344 + local.get $1 + call $~lib/array/Array#__get + local.get $0 + i32.const 255 + i32.and + i32.le_u + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 8 + local.get $1 + i32.sub + return + end + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $assembly/program/liftBytes (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + call $~lib/array/Array#get:length + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.lt_s + if + i32.const 1504 + i32.const 1744 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=4 + local.get $2 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/codec/Decoder#constructor (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 38 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/util/string/joinStringArray (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $1 + i32.const 1 + i32.sub + local.tee $5 + i32.const 0 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15424 + return + end + local.get $5 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + i32.const 15424 + local.get $0 + select + return + end + loop $for-loop|0 + local.get $1 + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $4 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $6 + i32.store offset=4 + local.get $6 + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $3 + local.get $6 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + i32.add + local.set $3 + end + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + i32.const 0 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $2 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + local.tee $1 + local.get $5 + i32.mul + i32.add + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $6 + i32.store offset=12 + i32.const 0 + local.set $3 + loop $for-loop|1 + local.get $3 + local.get $5 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $3 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $7 + i32.store offset=4 + local.get $7 + if + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $6 + local.get $4 + i32.const 1 + i32.shl + i32.add + local.get $7 + local.get $7 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + local.tee $7 + i32.const 1 + i32.shl + memory.copy + local.get $4 + local.get $7 + i32.add + local.set $4 + end + local.get $1 + if + local.get $6 + local.get $4 + i32.const 1 + i32.shl + i32.add + local.get $2 + local.get $1 + i32.const 1 + i32.shl + memory.copy + local.get $1 + local.get $4 + i32.add + local.set $4 + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $5 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $0 + i32.store offset=4 + local.get $0 + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $6 + local.get $4 + i32.const 1 + i32.shl + i32.add + local.get $0 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + memory.copy + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store + local.get $0 + local.get $1 + i32.const 15424 + call $~lib/util/string/joinStringArray + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/Decoder#ensureBytes (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + call $~lib/typedarray/Uint8Array#get:length + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + i32.sub + call $~lib/number/I32#toString + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 15584 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 15588 + local.get $1 + i32.store + i32.const 15584 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 15584 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 15596 + local.get $0 + i32.store + i32.const 15584 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 15584 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=4 + i32.const 15584 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 17408 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/ValOffset#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 40 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/codec/Decoder#varU32 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=4 + local.set $4 + i32.const 1 + global.set $~argumentsLength + local.get $1 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + i32.const 1 + global.set $~argumentsLength + i32.const 15392 + i32.load + call_indirect (type $2) + i32.const 255 + i32.and + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $1 + block $__inlined_func$assembly/codec/decodeVarU32$1 (result i32) + local.get $5 + i32.eqz + if + local.get $1 + i32.const 1 + call $assembly/codec/ValOffset#constructor + br $__inlined_func$assembly/codec/decodeVarU32$1 + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $5 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $5 + call $~lib/number/I32#toString + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + call $~lib/number/I32#toString + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 17632 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + i32.const 17636 + local.get $0 + i32.store + i32.const 17632 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 17632 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + i32.const 17644 + local.get $1 + i32.store + i32.const 17632 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 17632 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=12 + i32.const 17632 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 17408 + i32.const 108 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.const 1 + i32.const 8 + local.get $5 + i32.sub + local.tee $1 + i32.shl + i32.const 0 + local.get $1 + i32.const 32 + i32.lt_u + select + i32.add + i32.const 256 + i32.sub + local.get $5 + i32.const 3 + i32.shl + i32.shl + local.set $6 + local.get $5 + i32.const 1 + i32.sub + local.set $1 + loop $for-loop|0 + local.get $1 + i32.const 0 + i32.ge_s + if + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $1 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + local.get $2 + i32.const 8 + i32.shl + i32.add + local.set $2 + local.get $1 + i32.const 1 + i32.sub + local.set $1 + br $for-loop|0 + end + end + local.get $2 + local.get $6 + i32.add + local.get $5 + i32.const 1 + i32.add + call $assembly/codec/ValOffset#constructor + end + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $2 + local.get $1 + i32.load offset=4 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/codec/Decoder#bytes (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/string/String#concat (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + local.tee $3 + local.get $2 + i32.add + local.tee $4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15424 + return + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $4 + i32.store offset=4 + local.get $4 + local.get $0 + local.get $2 + memory.copy + local.get $2 + local.get $4 + i32.add + local.get $1 + local.get $3 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/string/String.__concat (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + call $~lib/string/String#concat + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/index/disassemble~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + i32.const 255 + i32.and + i32.const 16 + call $~lib/util/number/utoa32 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 15824 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 15824 + i32.store + block $__inlined_func$~lib/string/String#padStart$2455 + i32.const 15820 + i32.load + i32.const -2 + i32.and + local.tee $2 + i32.eqz + local.get $5 + i32.const 4 + i32.gt_u + i32.or + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$~lib/string/String#padStart$2455 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store offset=4 + i32.const 4 + local.get $5 + i32.sub + local.tee $4 + local.get $2 + i32.gt_u + if + local.get $4 + local.get $4 + i32.const 2 + i32.sub + local.get $2 + i32.div_u + local.get $2 + i32.mul + local.tee $7 + i32.sub + local.set $8 + loop $while-continue|0 + local.get $6 + local.get $7 + i32.lt_u + if + local.get $3 + local.get $6 + i32.add + i32.const 15824 + local.get $2 + memory.copy + local.get $2 + local.get $6 + i32.add + local.set $6 + br $while-continue|0 + end + end + local.get $3 + local.get $7 + i32.add + i32.const 15824 + local.get $8 + memory.copy + else + local.get $3 + i32.const 15824 + local.get $4 + memory.copy + end + local.get $3 + local.get $4 + i32.add + local.get $1 + local.get $5 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + local.set $1 + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + call $~lib/string/String.__concat + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/codec/Decoder#u8 (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + local.get $0 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=4 + i32.const 1 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.const 2 + i32.shl + i32.add + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/Mask#isInstruction (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i64.extend_i32_s + local.get $1 + i64.extend_i32_u + i64.le_u + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + i32.eqz + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/Mask#skipBytesToNextInstruction (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $1 + i32.const 1 + i32.add + local.tee $1 + local.get $2 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $0 + i32.eqz + if + i32.const 17824 + i32.const 9152 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/BasicBlocks#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 34 + call $~lib/rt/itcms/__new + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.store + local.get $4 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $5 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $5 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.const 2 + i32.shl + i32.const 35 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 2 + call $~lib/staticarray/StaticArray#__set + loop $for-loop|0 + local.get $3 + local.get $5 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $3 + call $assembly/program/Mask#isInstruction + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $3 + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $6 + i32.store offset=4 + local.get $6 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $6 + local.get $0 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#__get + end + i32.load8_u offset=16 + if + local.get $5 + local.get $3 + i32.const 1 + i32.add + local.get $7 + i32.add + local.tee $6 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $6 + i32.const 2 + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + local.get $3 + local.get $2 + local.get $3 + call $~lib/staticarray/StaticArray#__get + i32.const 4 + i32.or + call $~lib/staticarray/StaticArray#__set + end + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $4 + local.get $2 + i32.store + local.get $4 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/program/deblob (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i64) + (local $10 i64) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $assembly/codec/Decoder#constructor + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/codec/Decoder#varU32 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/codec/Decoder#u8 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/codec/Decoder#varU32 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + local.get $5 + i32.mul + call $assembly/codec/Decoder#bytes + local.tee $14 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $11 + call $assembly/codec/Decoder#bytes + local.tee $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $11 + i32.const 7 + i32.add + i32.const 3 + i32.shr_u + call $assembly/codec/Decoder#bytes + local.tee $12 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + global.get $~lib/memory/__stack_pointer + block $__inlined_func$assembly/program/Mask#constructor$11 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 31 + call $~lib/rt/itcms/__new + local.tee $13 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=4 + local.get $13 + i32.const 0 + i32.store + local.get $13 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $11 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.const 2 + i32.shl + i32.const 32 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $13 + local.get $0 + i32.store + local.get $13 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.sub + local.set $1 + loop $for-loop|0 + local.get $1 + i32.const 0 + i32.ge_s + if + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $1 + call $~lib/typedarray/Uint8Array#__get + local.set $0 + local.get $1 + i32.const 3 + i32.shl + local.set $15 + i32.const 7 + local.set $2 + loop $for-loop|2 + local.get $2 + i32.const 0 + i32.ge_s + if + local.get $0 + i32.const 128 + i32.and + local.set $16 + local.get $0 + i32.const 1 + i32.shl + local.set $0 + local.get $2 + local.get $15 + i32.add + local.tee $7 + local.get $11 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.load + local.tee $8 + i32.store offset=4 + local.get $8 + local.get $7 + i32.const 25 + i32.const 0 + local.get $6 + i32.const 1 + i32.add + local.get $16 + select + local.tee $6 + local.get $6 + i32.const 25 + i32.ge_u + select + call $~lib/staticarray/StaticArray#__set + end + local.get $2 + i32.const 1 + i32.sub + local.set $2 + br $for-loop|2 + end + end + local.get $1 + i32.const 1 + i32.sub + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + br $__inlined_func$assembly/program/Mask#constructor$11 + end + br $folding-inner1 + end + local.tee $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 33 + call $~lib/rt/itcms/__new + local.tee $7 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + i32.const 0 + i32.store + local.get $7 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.const 255 + i32.and + local.tee $1 + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.div_s + else + i32.const 0 + end + call $~lib/staticarray/StaticArray#constructor + local.tee $8 + i32.store offset=8 + i32.const 0 + local.set $1 + loop $for-loop|01 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.gt_s + if + i64.const 0 + local.set $4 + local.get $5 + i32.const 1 + i32.sub + i32.const 255 + i32.and + local.set $2 + loop $for-loop|1 + local.get $2 + i32.const 0 + i32.ge_s + if + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + i64.const -1 + local.get $4 + i64.const 8 + i64.shl + local.tee $9 + local.get $14 + local.get $1 + local.get $2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i64.extend_i32_u + i64.add + local.tee $10 + local.get $4 + local.get $10 + i64.gt_u + local.get $4 + local.get $9 + i64.gt_u + i32.or + select + local.set $4 + local.get $2 + i32.const 1 + i32.sub + local.set $2 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $1 + local.get $5 + i32.const 255 + i32.and + local.tee $2 + i32.div_s + local.get $4 + call $~lib/staticarray/StaticArray#__set + local.get $1 + local.get $2 + i32.add + local.set $1 + br $for-loop|01 + end + end + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $7 + local.get $8 + i32.store + local.get $7 + local.get $8 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $0 + call $assembly/program/BasicBlocks#constructor + local.tee $1 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 30 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $2 + local.get $3 + i32.store + local.get $2 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $2 + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $2 + local.get $7 + i32.store offset=8 + local.get $2 + local.get $7 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $2 + local.get $1 + i32.store offset=12 + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $0 + i32.store offset=4 + local.get $0 + i32.eqz + if + i32.const 17824 + i32.const 9152 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/program/decodeArguments (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 1264 + i32.store + i32.const 1264 + local.get $0 + call $~lib/array/Array#__get + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 1264 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 1264 + local.get $0 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#constructor + local.tee $4 + i32.store offset=4 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $3 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $4 + local.get $3 + local.get $1 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + i32.const 2 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 2272 + i32.store offset=8 + local.get $4 + local.get $2 + i32.const 2272 + local.get $0 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $1) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 2 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 2272 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 2272 + local.get $0 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $1) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/getAssembly (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 17952 + return + end + i32.const 15424 + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + loop $for-loop|0 + local.get $3 + local.get $4 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store + local.get $2 + local.get $3 + call $assembly/program/Mask#isInstruction + i32.eqz + if + i32.const 18032 + i32.const 18144 + i32.const 46 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + local.set $2 + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $5 + i32.store + local.get $2 + local.get $5 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $5 + i32.store + local.get $5 + local.get $2 + call $~lib/array/Array#__get + end + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 18224 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 18224 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + call $~lib/number/I32#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 18256 + i32.store offset=16 + local.get $7 + i32.const 18256 + call $~lib/string/String#concat + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $1 + local.get $7 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $6 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.const 255 + i32.and + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $2 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 18352 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + i32.const 18356 + local.get $2 + i32.store + i32.const 18352 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 18352 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=16 + i32.const 18352 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + local.get $2 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store + local.get $2 + local.get $3 + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $8 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + local.get $8 + local.get $3 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $6 + call $assembly/program/decodeArguments + local.tee $2 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + i32.const 42 + i32.const 0 + call $~lib/rt/__newArray + local.tee $8 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $8 + i32.const 0 + local.get $2 + i32.load + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $8 + i32.const 1 + local.get $2 + i32.load offset=4 + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $8 + i32.const 2 + local.get $2 + i32.load offset=8 + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $8 + i32.const 3 + local.get $2 + i32.load offset=12 + call $~lib/array/Array#__set + local.get $8 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 1136 + i32.store + i32.const 1136 + local.get $5 + i32.load offset=4 + call $~lib/array/Array#__get + local.set $5 + i32.const 0 + local.set $2 + loop $for-loop|1 + local.get $2 + local.get $5 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $8 + local.get $2 + call $~lib/array/Array#__get + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $9 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + i32.const 18448 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + i32.const 18452 + local.get $9 + i32.store + i32.const 18448 + local.get $9 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 18448 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=16 + i32.const 18448 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $1 + local.get $9 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|1 + end + end + local.get $3 + local.get $6 + i32.add + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/codec/Decoder#u24 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 3 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + local.get $0 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=4 + i32.const 3 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/Decoder#u32 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 4 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + local.get $0 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 3 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=4 + i32.const 4 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/Decoder#isExhausted (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.le_s + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/decodeSpi (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $assembly/codec/Decoder#constructor + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#u24 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#u24 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 2 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $3 + local.get $1 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get + drop + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $3 + local.get $1 + i32.load offset=4 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + drop + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $1 + i32.load offset=4 + i32.const 2 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#u24 + drop + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $2 + call $assembly/codec/Decoder#bytes + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $0 + call $assembly/codec/Decoder#bytes + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#u32 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $0 + call $assembly/codec/Decoder#bytes + local.tee $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 18480 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $0 + i32.store offset=8 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + i32.load offset=4 + i32.sub + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 18480 + local.get $0 + call $~lib/string/String#concat + i32.const 17408 + i32.const 31 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/program/deblob + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner2 + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner2 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $assembly/program/liftBytes + local.tee $3 + i32.store offset=4 + i32.const 15424 + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + local.get $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + block $__inlined_func$assembly/program/extractCodeAndMetadata$14 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + call $assembly/codec/Decoder#constructor + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/codec/Decoder#varU32 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + call $assembly/codec/Decoder#bytes + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.load offset=4 + local.set $7 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $6 + local.get $7 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.load offset=4 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $2 + local.get $6 + call $~lib/typedarray/Uint8Array#get:length + local.get $7 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 37 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $2 + local.get $6 + i32.store + local.get $2 + local.get $6 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $2 + local.get $3 + i32.store offset=4 + local.get $2 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + br $__inlined_func$assembly/program/extractCodeAndMetadata$14 + end + br $folding-inner2 + end + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 17680 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 17680 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 17728 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 17680 + i32.const 17728 + call $~lib/string/String.__concat + local.tee $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + local.tee $8 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 17760 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner2 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 17760 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + i32.load offset=4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $2 + loop $for-loop|0 + local.get $2 + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $4 + local.get $9 + i32.add + i32.load8_u + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + i32.const 4 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $5 + local.get $4 + local.get $8 + i32.const 17760 + i32.load + call_indirect (type $7) + local.tee $0 + i32.store offset=8 + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + local.get $6 + local.get $0 + call $~lib/string/String.__concat + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 17792 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 17792 + call $~lib/string/String.__concat + local.tee $0 + i32.store offset=8 + end + local.get $1 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + call $assembly/program/deblob + local.tee $1 + i32.store offset=36 + br $folding-inner1 + end + local.get $1 + i32.const 1 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + call $assembly/program/decodeSpi + local.tee $1 + i32.store offset=40 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 18608 + i32.store + local.get $1 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + i32.const 18608 + local.get $0 + call $~lib/string/String#concat + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=20 + local.get $1 + call $assembly/api-generic/getAssembly + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + local.get $0 + local.get $1 + call $~lib/string/String.__concat + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api-generic/VmInput#constructor (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 47 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 43 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store + local.get $2 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 104 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $2 + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 104 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 13 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + i32.const 1 + global.set $~argumentsLength + block $__inlined_func$~lib/array/Array#fill@varargs$16 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load offset=12 + local.tee $4 + i32.const 0 + local.get $4 + i32.const 0 + i32.le_s + select + local.tee $0 + local.get $4 + local.tee $4 + i32.lt_s + if + local.get $3 + local.get $0 + i32.const 3 + i32.shl + i32.add + i32.const 0 + local.get $4 + local.get $0 + i32.sub + i32.const 3 + i32.shl + memory.fill + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + br $__inlined_func$~lib/array/Array#fill@varargs$16 + end + br $folding-inner1 + end + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 18656 + call $~lib/rt/__newArray + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store offset=16 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 18688 + call $~lib/rt/__newArray + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store offset=20 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 18720 + call $~lib/rt/__newArray + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store offset=24 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory-page/Arena#constructor (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 16 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + local.get $0 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 524288 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 17 + i32.const 18752 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $0 + local.get $2 + i32.store + local.get $0 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 128 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $4 + i32.store offset=12 + loop $for-loop|0 + local.get $1 + i32.const 128 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $1 + i32.const 12 + i32.shl + local.tee $3 + local.get $4 + i32.const 20 + i32.sub + i32.load offset=16 + local.tee $5 + i32.gt_u + if + i32.const 1504 + i32.const 1744 + i32.const 1860 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.const 4096 + i32.add + local.get $5 + i32.gt_s + if + i32.const 9200 + i32.const 1744 + i32.const 1874 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $5 + i32.store offset=8 + local.get $5 + local.get $4 + i32.store + local.get $5 + local.get $4 + i32.const 0 + call $~lib/rt/itcms/__link + local.get $5 + i32.const 4096 + i32.store offset=8 + local.get $5 + local.get $3 + local.get $4 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $1 + local.get $5 + call $assembly/memory-page/RawPage#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $2 + i32.load offset=12 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load offset=4 + local.tee $6 + i32.const 4 + i32.add + local.get $6 + local.get $3 + i32.const 1 + i32.sub + i32.const 2 + i32.shl + memory.copy + local.get $6 + local.get $5 + i32.store + local.get $2 + local.get $5 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory/MemoryBuilder#constructor (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 50 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.const 18 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 16 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.store + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 48 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + call $assembly/memory-page/Arena#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory/MemoryBuilder#setData (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + loop $while-continue|0 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + i32.gt_s + if + local.get $2 + i32.const 12 + i32.shr_u + local.tee $4 + i32.const 16 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + i32.const 18784 + i32.store offset=4 + local.get $4 + i32.const 10 + call $~lib/util/number/utoa32 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 18784 + local.get $0 + call $~lib/string/String#concat + i32.const 18880 + i32.const 67 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $5 + i32.store offset=4 + local.get $5 + local.get $4 + call $"~lib/map/Map#has" + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + call $assembly/memory-page/Arena#acquire + local.tee $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $1 + local.get $5 + call $assembly/memory-page/Page#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $6 + local.get $4 + local.get $5 + call $"~lib/map/Map#set" + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + local.get $4 + call $"~lib/map/Map#get" + local.tee $5 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + i32.const 4096 + local.get $2 + i32.const 4095 + i32.and + local.tee $7 + i32.sub + local.tee $4 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + local.set $4 + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + local.tee $5 + i32.store offset=16 + local.get $5 + call $assembly/memory-page/RawPage#get:data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + i32.const 0 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $~lib/typedarray/Uint8Array#get:length + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + local.get $7 + local.get $8 + i32.add + i32.lt_s + if + i32.const 1504 + i32.const 1744 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $7 + local.get $5 + i32.load offset=4 + i32.add + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.load offset=4 + local.get $8 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + i32.add + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $3 + i32.store + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory/MemoryBuilder#build (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 15 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $0 + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $0 + local.get $3 + i32.store offset=8 + local.get $0 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + local.get $1 + i32.const 12 + i32.shr_u + local.tee $1 + i32.const 16 + i32.lt_u + if + i32.const 18944 + i32.const 18880 + i32.const 104 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $0 + local.get $1 + local.get $1 + i32.const 1 + i32.sub + local.get $3 + local.get $1 + call $"~lib/map/Map#has" + select + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api-generic/buildMemory (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + i32.const 65536 + local.set $3 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $4 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + i32.load offset=8 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + i32.load + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $0 + local.get $8 + local.get $7 + local.get $9 + call $assembly/memory/MemoryBuilder#setData + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load offset=8 + i32.const 2 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $3 + local.get $6 + i32.load + i32.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load + local.set $3 + end + end + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + local.get $5 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.tee $1 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $6 + i32.store offset=20 + i32.const 0 + local.set $4 + loop $for-loop|2 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/typedarray/Uint8Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + local.get $6 + local.get $4 + local.get $7 + local.get $4 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|2 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $0 + i32.const 0 + local.get $1 + local.get $6 + call $assembly/memory/MemoryBuilder#setData + local.get $5 + i32.const 1 + i32.add + local.set $5 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + call $assembly/memory/MemoryBuilder#build + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/interpreter/Interpreter#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 33 + i32.const 29 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store + local.get $3 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=8 + local.get $3 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=12 + local.get $3 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store8 offset=32 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $3 + local.get $0 + i32.store + local.get $3 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + i32.store offset=4 + local.get $3 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $3 + local.get $2 + i32.store offset=8 + local.get $3 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 51 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $3 + local.get $0 + i32.store offset=12 + local.get $3 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const -1 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store8 offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/util/string/joinIntegerArray (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $1 + i32.const 1 + i32.sub + local.tee $4 + i32.const 0 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15424 + return + end + local.get $4 + i32.eqz + if + local.get $0 + i64.load + i32.const 10 + call $~lib/util/number/utoa64 + local.set $0 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 18412 + i32.load + i32.const 1 + i32.shr_u + local.tee $5 + i32.const 20 + i32.add + local.get $4 + i32.mul + i32.const 20 + i32.add + local.tee $6 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store offset=4 + loop $for-loop|0 + local.get $3 + local.get $4 + i32.lt_s + if + local.get $1 + local.get $2 + i32.const 1 + i32.shl + i32.add + local.get $0 + local.get $3 + i32.const 3 + i32.shl + i32.add + i64.load + call $~lib/util/number/itoa_buffered + local.get $2 + i32.add + local.set $2 + local.get $5 + if + local.get $1 + local.get $2 + i32.const 1 + i32.shl + i32.add + i32.const 18416 + local.get $5 + i32.const 1 + i32.shl + memory.copy + local.get $2 + local.get $5 + i32.add + local.set $2 + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + local.get $6 + local.get $1 + local.get $2 + i32.const 1 + i32.shl + i32.add + local.get $0 + local.get $4 + i32.const 3 + i32.shl + i32.add + i64.load + call $~lib/util/number/itoa_buffered + local.get $2 + i32.add + local.tee $2 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.gt_s + select + local.tee $2 + local.get $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + local.tee $1 + local.get $1 + local.get $2 + i32.gt_s + select + local.tee $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.le_s + select + i32.const 1 + i32.shl + local.set $3 + block $__inlined_func$~lib/string/String#substring$2458 + local.get $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.ge_s + select + i32.const 1 + i32.shl + local.tee $2 + local.get $3 + i32.sub + local.tee $4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15424 + local.set $0 + br $__inlined_func$~lib/string/String#substring$2458 + end + local.get $3 + i32.eqz + local.get $2 + local.get $1 + i32.const 1 + i32.shl + i32.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$~lib/string/String#substring$2458 + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store offset=4 + local.get $1 + local.get $0 + local.get $3 + i32.add + local.get $4 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + local.set $0 + end + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/staticarray/StaticArray#join (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store + local.get $0 + local.get $1 + call $~lib/util/string/joinIntegerArray + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/runVm~anonymous|0 (param $0 i64) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 17728 + i32.store + local.get $0 + i32.const 16 + call $~lib/util/number/utoa64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 17728 + local.get $1 + call $~lib/string/String#concat + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + local.tee $5 + i32.const 2 + i32.const 52 + i32.const 0 + call $~lib/rt/__newArray + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=4 + local.set $6 + loop $for-loop|0 + local.get $2 + local.get $5 + i32.lt_s + if + local.get $0 + local.get $2 + i32.const 3 + i32.shl + i32.add + i64.load + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 3 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $7 + local.get $2 + local.get $0 + local.get $1 + i32.load + call_indirect (type $12) + local.tee $4 + i32.store offset=8 + local.get $6 + local.get $2 + i32.const 2 + i32.shl + i32.add + local.get $4 + i32.store + local.get $3 + local.get $4 + i32.const 1 + call $~lib/rt/itcms/__link + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/array/Array<~lib/string/String>#join (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store + i32.const 18416 + call $~lib/util/string/joinStringArray + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/resolveArguments (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner6 + block $folding-inner5 + block $folding-inner4 + block $folding-inner3 + block $folding-inner2 + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + local.get $2 + call $assembly/program/decodeArguments + local.tee $2 + i32.store offset=4 + local.get $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.const 54 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/object/Object#constructor + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + call $assembly/arguments/Args#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $6 + local.get $1 + i32.store offset=32 + local.get $6 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i32.store offset=32 + local.get $6 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + block $case13|0 + block $case12|0 + block $case11|0 + block $case8|0 + block $case5|0 + block $case4|0 + block $case2|0 + local.get $0 + br_table $folding-inner6 $folding-inner1 $case2|0 $folding-inner1 $case4|0 $case5|0 $folding-inner3 $folding-inner3 $case8|0 $folding-inner4 $folding-inner4 $case11|0 $case12|0 $case13|0 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s + i64.store + br $folding-inner2 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + br $folding-inner2 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + i64.load32_u + i64.const 32 + i64.shl + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $4 + local.get $2 + i64.load32_u offset=4 + i64.add + i64.store offset=8 + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=8 + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=12 + i64.store offset=24 + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=8 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=16 + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + i32.const 19552 + i32.store + local.get $0 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + i32.const 19552 + local.get $0 + call $~lib/string/String#concat + i32.const 19632 + i32.const 347 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s + i64.store + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=4 + i64.store offset=8 + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=4 + i64.store offset=8 + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=8 + i64.store offset=16 + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $assembly/interpreter/branch (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 56 + call $~lib/rt/itcms/__new + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + call $~lib/object/Object#constructor + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + block $__inlined_func$assembly/program/BasicBlocks#isStart$2459 + local.get $1 + local.get $2 + i32.add + local.tee $1 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + i32.const 2 + i32.and + i32.const 0 + i32.ne + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$assembly/program/BasicBlocks#isStart$2459 + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + local.set $0 + end + local.get $0 + if + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 1 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $1 + i32.store offset=4 + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/interpreter/Interpreter#nextStep (param $0 i32) (result i32) + (local $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner6 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner6 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=20 + i32.const 3 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const -1 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=28 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const -1 + i32.store offset=28 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + block $folding-inner5 + local.get $0 + i32.load offset=20 + i32.const -1 + i32.ne + br_if $folding-inner5 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + block $folding-inner4 + local.get $0 + i32.load offset=28 + i32.const -1 + i32.ne + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=28 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const -1 + i32.store offset=28 + br $folding-inner4 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=16 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=4 + local.tee $3 + i32.store + local.get $3 + local.get $1 + call $assembly/program/Mask#isInstruction + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 + i32.store + local.get $1 + global.get $assembly/instructions/MISSING_INSTRUCTION + i64.load offset=8 + call $assembly/gas/GasCounter#sub@override + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 4 + i32.store offset=20 + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store offset=20 + end + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load + local.tee $3 + i32.store + local.get $3 + local.get $1 + call $~lib/typedarray/Uint8Array#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length + local.get $3 + i32.gt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $4 + i32.store + local.get $4 + local.get $3 + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $5 + i32.store + block $folding-inner3 + block $folding-inner1 + block $folding-inner0 + local.get $5 + local.get $4 + i64.load offset=8 + call $assembly/gas/GasCounter#sub@override + br_if $folding-inner0 + local.get $4 + global.get $assembly/instructions/MISSING_INSTRUCTION + i32.eq + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + local.tee $5 + i32.store + local.get $5 + local.get $1 + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $8 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.load + local.tee $8 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + local.get $8 + local.get $1 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $5 + call $assembly/program/decodeArguments + local.tee $6 + i32.store offset=16 + local.get $4 + global.get $assembly/instructions/SBRK + i32.eq + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u offset=32 + else + i32.const 0 + end + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $4 + i32.const 12 + local.get $6 + i64.load32_u + local.tee $2 + i32.wrap_i64 + local.get $2 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + i64.const 4095 + i64.add + i64.const 12 + i64.shr_u + i64.const 4 + i64.shl + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $4 + i32.store + local.get $4 + local.get $2 + call $assembly/gas/GasCounter#sub@override + br_if $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + i32.const 15264 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15264 + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.tee $3 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $7 + i32.store offset=8 + i32.const 3 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $6 + local.get $4 + local.get $7 + local.get $3 + i32.load + call_indirect (type $0) + local.tee $3 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + block $break|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $3 + i32.load + br_table $case3|0 $case1|0 $case0|0 $case2|0 $break|0 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $__inlined_func$assembly/interpreter/dJump$17 + block $folding-inner11 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner6 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner6 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 55 + call $~lib/rt/itcms/__new + local.tee $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + call $~lib/object/Object#constructor + local.tee $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $3 + i32.const -65536 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + i32.store + br $__inlined_func$assembly/interpreter/dJump$17 + end + local.get $3 + i32.const 1 + i32.and + i32.const 1 + local.get $3 + select + br_if $folding-inner11 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $4 + i32.store offset=4 + local.get $3 + i32.const 1 + i32.shr_u + i32.const 1 + i32.sub + local.tee $3 + local.get $4 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.ge_u + br_if $folding-inner11 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $1 + i32.store offset=4 + local.get $1 + local.get $3 + call $~lib/staticarray/StaticArray#__get + local.tee $2 + i64.const 4294967296 + i64.ge_u + br_if $folding-inner11 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $2 + i64.store32 offset=4 + br $__inlined_func$assembly/interpreter/dJump$17 + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 2 + i32.store + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + local.tee $1 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.load + i32.const 1 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=20 + br $folding-inner4 + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + i32.const 2 + i32.eq + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=12 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $1 + i32.load offset=4 + i32.const 0 + call $assembly/interpreter/branch + local.tee $1 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load8_u + i32.eqz + br_if $folding-inner1 + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load offset=12 + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + local.get $1 + local.get $3 + i32.load offset=4 + call $assembly/interpreter/branch + local.tee $1 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load8_u + i32.eqz + br_if $folding-inner1 + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=12 + i32.const 3 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 3 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $0 + local.get $3 + i32.load offset=16 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=16 + i32.const 1 + i32.add + local.get $5 + i32.add + i32.store offset=28 + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=12 + i32.const 1 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 + i32.store + local.get $1 + i64.const 1 + call $assembly/gas/GasCounter#sub@override + drop + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=16 + i32.const 65536 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store offset=20 + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 2 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $0 + local.get $3 + i32.load offset=16 + i32.store offset=24 + end + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=12 + i32.const 2 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 + i32.store + local.get $1 + i64.const 1 + call $assembly/gas/GasCounter#sub@override + drop + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=12 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $0 + local.get $3 + i32.load offset=16 + i32.store offset=24 + br $folding-inner5 + end + i32.const 19968 + i32.const 20016 + i32.const 173 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=16 + local.get $5 + i32.const 1 + i32.add + i32.add + i32.store offset=16 + br $folding-inner4 + end + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 4 + i32.store offset=20 + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store offset=20 + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.load offset=4 + i32.store offset=16 + end + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 1 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/array/Array#set:length (param $0 i32) (param $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + local.get $1 + i32.const 2 + i32.const 0 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#push (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $0 + i32.load offset=12 + local.tee $2 + i32.const 1 + i32.add + local.tee $3 + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.load offset=4 + i32.add + local.get $1 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/InitialChunk#constructor (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 45 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 20192 + call $~lib/rt/__newArray + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/array/Array#push (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $0 + i32.load offset=12 + local.tee $2 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $2 + i32.const 2 + i32.shl + i32.add + local.get $1 + i32.store + local.get $0 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/getOutputChunks (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 20160 + call $~lib/rt/__newArray + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.load offset=8 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.load offset=16 + local.set $8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 42 + call $~lib/rt/itcms/__new + local.tee $9 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store + local.get $9 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=12 + local.get $8 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9152 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + local.get $8 + local.get $8 + i32.const 8 + i32.le_u + select + i32.const 2 + i32.shl + local.tee $10 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $9 + local.get $5 + i32.store + local.get $9 + local.get $5 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $10 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $8 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + loop $for-loop|0 + local.get $2 + local.get $8 + i32.lt_s + if + local.get $7 + local.get $2 + i32.const 12 + i32.mul + i32.add + local.tee $5 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $1 + local.get $5 + i32.load + call $~lib/array/Array#__set + local.get $1 + i32.const 1 + i32.add + local.set $1 + end + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $1 + call $~lib/array/Array#set:length + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + i32.const 0 + local.set $1 + loop $for-loop|00 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/array/Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $4 + call $~lib/array/Array#__get + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $5 + call $"~lib/map/Map#get" + local.tee $6 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $2 + i32.store offset=4 + local.get $2 + i32.load offset=4 + if + i32.const 0 + local.set $2 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + local.get $7 + call $assembly/memory-page/RawPage#get:data + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + local.get $7 + call $assembly/memory-page/RawPage#get:data + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $2 + call $~lib/typedarray/Uint8Array#__get + local.tee $7 + if + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $8 + i32.store offset=4 + local.get $8 + local.get $7 + call $~lib/array/Array#push + else + global.get $~lib/memory/__stack_pointer + call $assembly/api-generic/InitialChunk#constructor + local.tee $1 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $5 + i32.const 12 + i32.shl + local.get $2 + i32.add + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 1 + i32.const 0 + i32.const 27 + i32.const 0 + call $~lib/rt/__newArray + local.tee $8 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.load offset=12 + i32.eqz + if + local.get $8 + i32.const 1 + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + i32.store offset=12 + end + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.load offset=4 + local.get $7 + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $1 + local.get $8 + i32.store offset=4 + local.get $1 + local.get $8 + i32.const 0 + call $~lib/rt/itcms/__link + end + else + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + call $~lib/array/Array#push + i32.const 0 + local.set $1 + end + end + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|1 + end + end + end + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|00 + end + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + call $~lib/array/Array#push + end + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $"~lib/map/Map#values" (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=16 + local.set $2 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 57 + call $~lib/rt/itcms/__new + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + i32.store + local.get $6 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + i32.store offset=12 + local.get $2 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9152 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + local.get $2 + local.get $2 + i32.const 8 + i32.le_u + select + i32.const 2 + i32.shl + local.tee $0 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $6 + local.get $5 + i32.store + local.get $6 + local.get $5 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + loop $for-loop|0 + local.get $2 + local.get $3 + i32.gt_s + if + local.get $4 + local.get $3 + i32.const 12 + i32.mul + i32.add + local.tee $5 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $1 + local.tee $0 + i32.const 1 + i32.add + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $0 + local.get $6 + i32.load offset=12 + i32.ge_u + if + local.get $0 + i32.const 0 + i32.lt_s + if + i32.const 1504 + i32.const 9152 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $6 + local.get $0 + i32.const 1 + i32.add + local.tee $5 + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $5 + i32.store offset=12 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load offset=4 + local.get $0 + i32.const 2 + i32.shl + i32.add + local.get $7 + i32.store + local.get $6 + local.get $7 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $1 + call $~lib/array/Array#set:length + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api-generic/runVm (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + (local $17 i32) + global.get $~lib/memory/__stack_pointer + i32.const 124 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 124 + memory.fill + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=16 + local.tee $7 + i32.store offset=4 + local.get $7 + call $assembly/program/liftBytes + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $assembly/program/deblob + local.tee $10 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 13 + call $~lib/staticarray/StaticArray#constructor + local.tee $6 + i32.store offset=16 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $3 + local.get $6 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $3 + local.get $7 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + i32.load offset=4 + local.get $3 + i32.const 3 + i32.shl + i32.add + i64.load + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + local.get $3 + local.get $5 + call $~lib/staticarray/StaticArray#__set + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + call $assembly/memory/MemoryBuilder#constructor + local.tee $3 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=20 + local.tee $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=24 + local.tee $8 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $7 + local.get $8 + call $assembly/api-generic/buildMemory + local.tee $3 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $10 + local.get $6 + local.get $3 + call $assembly/interpreter/Interpreter#constructor + local.tee $11 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $2 + i32.store8 offset=32 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $11 + local.get $0 + i32.load offset=4 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=12 + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i64.load offset=8 + call $assembly/gas/GasCounter#set@override + i32.const 1 + local.set $0 + loop $for-loop|1 + block $for-break1 + local.get $0 + i32.eqz + if + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + call $~lib/staticarray/StaticArray#join + local.tee $0 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + i32.const 19152 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19156 + local.get $0 + i32.store + i32.const 19152 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19152 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + i32.const 19152 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 19216 + i32.store offset=40 + local.get $6 + i32.const 19216 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store offset=8 + local.get $2 + call $~lib/array/Array<~lib/string/String>#join + local.tee $0 + i32.store offset=44 + global.get $~lib/memory/__stack_pointer + i32.const 19184 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19188 + local.get $0 + i32.store + i32.const 19184 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19184 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + i32.const 19184 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 19248 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + local.get $11 + i32.load offset=20 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19248 + local.get $0 + call $~lib/string/String#concat + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + br $for-break1 + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 19312 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + local.get $11 + i32.load offset=16 + i32.const 10 + call $~lib/util/number/utoa32 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19312 + local.get $0 + call $~lib/string/String#concat + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 19344 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + local.get $11 + i32.load offset=20 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19344 + local.get $0 + call $~lib/string/String#concat + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 19056 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store offset=40 + local.get $6 + call $~lib/staticarray/StaticArray#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19056 + local.get $0 + call $~lib/string/String#concat + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 19056 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=48 + global.get $~lib/memory/__stack_pointer + i32.const 19392 + i32.store offset=52 + local.get $6 + i32.const 19392 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store offset=40 + local.get $0 + call $~lib/array/Array<~lib/string/String>#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19056 + local.get $0 + call $~lib/string/String#concat + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.load offset=16 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $2 + i32.store + local.get $2 + call $~lib/typedarray/Uint8Array#get:length + local.get $0 + i32.gt_u + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $0 + local.get $11 + i32.load offset=16 + call $~lib/typedarray/Uint8Array#__get + else + i32.const 0 + end + local.set $0 + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $2 + i32.store + local.get $0 + local.get $2 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $2 + i32.store + local.get $2 + local.get $0 + call $~lib/array/Array#__get + end + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.load offset=4 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $3 + local.get $11 + i32.load offset=16 + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $7 + i32.store offset=56 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=60 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 255 + i32.and + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $0 + i32.store offset=64 + global.get $~lib/memory/__stack_pointer + i32.const 19504 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + i32.const 19508 + local.get $7 + i32.store + i32.const 19504 + local.get $7 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19504 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19516 + local.get $0 + i32.store + i32.const 19504 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19504 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + i32.const 19504 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load + local.tee $7 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.load + local.tee $7 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + local.get $11 + i32.load offset=16 + i32.const 1 + i32.add + local.set $8 + i32.const 1 + global.set $~argumentsLength + local.get $7 + local.get $8 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=4 + local.tee $8 + i32.store offset=4 + local.get $7 + local.get $3 + local.get $8 + call $assembly/program/resolveArguments + local.tee $12 + i32.store offset=68 + local.get $12 + if + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load + call $~lib/util/number/itoa64 + local.tee $0 + i32.store offset=72 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.load offset=32 + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $2 + i32.store offset=76 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $3 + i32.store offset=80 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=8 + call $~lib/util/number/itoa64 + local.tee $7 + i32.store offset=84 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.load offset=32 + local.tee $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.load offset=4 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $8 + i32.store offset=88 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=8 + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $13 + i32.store offset=92 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=16 + call $~lib/util/number/itoa64 + local.tee $14 + i32.store offset=96 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.load offset=32 + local.tee $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.load offset=8 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $9 + i32.store offset=100 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=16 + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $15 + i32.store offset=104 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=24 + call $~lib/util/number/itoa64 + local.tee $16 + i32.store offset=108 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.load offset=32 + local.tee $17 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.load offset=12 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $17 + i32.store offset=112 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=24 + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $12 + i32.store offset=116 + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19844 + local.get $0 + i32.store + i32.const 19840 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + i32.const 19852 + local.get $2 + i32.store + i32.const 19840 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + i32.const 19860 + local.get $3 + i32.store + i32.const 19840 + local.get $3 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + i32.const 19868 + local.get $7 + i32.store + i32.const 19840 + local.get $7 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + i32.const 19876 + local.get $8 + i32.store + i32.const 19840 + local.get $8 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + i32.const 19884 + local.get $13 + i32.store + i32.const 19840 + local.get $13 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + i32.const 19892 + local.get $14 + i32.store + i32.const 19840 + local.get $14 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + i32.const 19900 + local.get $9 + i32.store + i32.const 19840 + local.get $9 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store offset=8 + i32.const 19908 + local.get $15 + i32.store + i32.const 19840 + local.get $15 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + i32.const 19916 + local.get $16 + i32.store + i32.const 19840 + local.get $16 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=8 + i32.const 19924 + local.get $17 + i32.store + i32.const 19840 + local.get $17 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + i32.const 19932 + local.get $12 + i32.store + i32.const 19840 + local.get $12 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + i32.const 19840 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + end + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $assembly/interpreter/Interpreter#nextStep + local.set $0 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 44 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/object/Object#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const -1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 0 + i32.const 3 + i32.const 43 + i32.const 20096 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.store offset=4 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 20128 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=120 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $1 + local.get $11 + i32.load offset=20 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=4 + local.tee $0 + i32.store offset=8 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.tee $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.gt_s + select + local.tee $2 + i32.const 3 + i32.const 43 + i32.const 0 + call $~lib/rt/__newArray + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=4 + local.get $0 + local.get $2 + i32.const 3 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $1 + local.get $3 + i32.store offset=4 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $1 + local.get $11 + i32.load offset=16 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=12 + local.tee $0 + i32.store offset=4 + local.get $1 + local.get $0 + call $assembly/gas/GasCounter#get@override + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=8 + local.tee $0 + i32.store offset=8 + local.get $0 + call $assembly/api-generic/getOutputChunks + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=12 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $1 + local.get $11 + i32.load offset=24 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=8 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + call $"~lib/map/Map#values" + local.tee $2 + i32.store offset=8 + loop $for-loop|01 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $2 + local.get $4 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $3 + local.get $6 + call $~lib/array/Array#push + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|01 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 16 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.store + local.get $0 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 48 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.store offset=8 + local.get $0 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 4 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 124 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/program-build/skipBytes (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $folding-inner3 (result i32) + block $folding-inner2 + block $folding-inner1 + block $folding-inner0 + block $case13|0 + block $case12|0 + block $case11|0 + block $case8|0 + block $case7|0 + block $case6|0 + block $case5|0 + block $case4|0 + block $case2|0 + block $case0|0 + local.get $0 + br_table $case0|0 $folding-inner0 $case2|0 $folding-inner0 $case4|0 $case5|0 $case6|0 $case7|0 $case8|0 $folding-inner2 $folding-inner2 $case11|0 $case12|0 $case13|0 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u + i32.const 1 + i32.add + local.tee $0 + i32.const 255 + i32.and + i32.const 1 + i32.add + block $__inlined_func$assembly/program-build/immBytes$2177 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $1 + local.get $0 + i32.const 1 + i32.add + i32.const 255 + i32.and + local.tee $0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$2177 + drop + local.get $1 + local.get $0 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.add + br $folding-inner3 + end + block $__inlined_func$assembly/program-build/immBytes$2179 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $0 + i32.const 0 + i32.le_s + br_if $__inlined_func$assembly/program-build/immBytes$2179 + drop + local.get $0 + i32.const 1 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.const 1 + i32.add + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 9 + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=8 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=12 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 1 + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u + i32.const 1 + i32.add + local.tee $0 + i32.const 255 + i32.and + i32.const 2 + i32.add + block $__inlined_func$assembly/program-build/immBytes$2185 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $1 + local.get $0 + i32.const 255 + i32.and + i32.const 2 + i32.add + local.tee $0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$2185 + drop + local.get $1 + local.get $0 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.add + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 2 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 19552 + i32.store + local.get $0 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + i32.const 19552 + local.get $0 + call $~lib/string/String#concat + i32.const 20368 + i32.const 73 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + block $__inlined_func$assembly/program-build/immBytes$2175 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $0 + i32.const 0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$2175 + drop + local.get $0 + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u offset=1 + i32.const 1 + i32.add + local.tee $0 + i32.const 255 + i32.and + i32.const 1 + i32.add + block $__inlined_func$assembly/program-build/immBytes$2181 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $1 + local.get $0 + i32.const 255 + i32.and + i32.const 1 + i32.add + local.tee $0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$2181 + drop + local.get $1 + local.get $0 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.add + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + i32.const 1 + i32.add + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program-build/buildMask (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $3 + i32.const 1073741820 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.const 58 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $2 + call $~lib/typedarray/Uint8Array#__get + local.set $1 + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length + local.get $1 + i32.gt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $4 + i32.store + local.get $4 + local.get $1 + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $2 + i32.const 1 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 1264 + i32.store + i32.const 1264 + local.get $1 + i32.load offset=4 + call $~lib/array/Array#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $4 + local.get $2 + i32.const 1 + i32.add + local.tee $4 + i32.add + i32.ge_s + if (result i32) + local.get $1 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 1 + global.set $~argumentsLength + local.get $0 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/program-build/skipBytes + local.get $2 + i32.add + else + local.get $2 + end + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 20448 + call $~lib/rt/__newArray + local.tee $4 + i32.store offset=12 + i32.const 0 + local.set $0 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $0 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + i32.lt_s + if + i32.const 0 + local.set $2 + local.get $0 + local.set $1 + loop $for-loop|3 + local.get $1 + local.get $0 + i32.const 8 + i32.add + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $2 + i32.const 255 + i32.and + i32.const 1 + i32.shr_u + local.tee $2 + i32.const 128 + i32.or + local.get $2 + local.get $1 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + i32.lt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $1 + call $~lib/staticarray/StaticArray#__get + else + i32.const 0 + end + select + local.set $2 + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|3 + end + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $2 + call $~lib/array/Array#push + local.get $0 + i32.const 8 + i32.add + local.set $0 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/codec/encodeVarU32 (param $0 i64) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i64) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner2 + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner2 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + local.get $0 + i64.eqz + if + i32.const 1 + call $~lib/typedarray/Uint8Array#constructor + local.set $3 + br $folding-inner1 + end + local.get $0 + i64.const 72057594037927936 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + i32.const 9 + call $~lib/typedarray/Uint8Array#constructor + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 255 + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $3 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + block $__inlined_func$~lib/dataview/DataView#constructor@varargs$38 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 59 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store + local.get $1 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + local.get $5 + i32.lt_u + local.get $5 + i32.const 1073741820 + i32.gt_u + i32.or + if + i32.const 9200 + i32.const 20480 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $1 + local.get $3 + i32.store + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + br $__inlined_func$~lib/dataview/DataView#constructor@varargs$38 + end + br $folding-inner2 + end + local.tee $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner2 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load offset=8 + i32.const 9 + i32.lt_s + if + i32.const 1504 + i32.const 20480 + i32.const 174 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load offset=4 + local.get $0 + i64.store offset=1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i64.const 562949953421312 + local.set $4 + i32.const 7 + local.set $1 + loop $for-loop|0 + local.get $1 + i32.const 0 + i32.ge_s + if + local.get $0 + local.get $4 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $3 + i32.store offset=16 + i32.const 256 + i32.const 1 + i32.const 8 + local.get $1 + i32.sub + local.tee $2 + i32.shl + i32.const 0 + local.get $2 + i32.const 32 + i32.lt_u + select + i32.sub + i64.extend_i32_s + local.get $0 + i32.const 1 + local.get $1 + i32.const 3 + i32.shl + local.tee $2 + i32.shl + i32.const 0 + local.get $2 + i32.const 32 + i32.lt_u + select + i64.extend_i32_s + local.tee $4 + i64.div_u + i64.add + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + local.get $6 + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $0 + local.get $4 + i64.rem_u + local.set $0 + i32.const 1 + local.set $2 + loop $for-loop|1 + local.get $2 + local.get $1 + i32.const 1 + i32.add + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $2 + local.get $0 + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $0 + i64.const 8 + i64.shr_u + local.set $0 + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|1 + end + end + br $folding-inner1 + end + local.get $4 + i64.const 7 + i64.shr_u + local.set $4 + local.get $1 + i32.const 1 + i32.sub + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20544 + i32.store offset=4 + local.get $0 + i32.const 10 + call $~lib/util/number/utoa64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + i32.const 20544 + local.get $1 + call $~lib/string/String#concat + i32.const 17408 + i32.const 160 + i32.const 3 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api/fillRegisters (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -8 + i32.and + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length + local.get $3 + i32.ne + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/array/Array#get:length + call $~lib/number/I32#toString + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + call $~lib/number/I32#toString + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 20768 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + i32.const 20772 + local.get $0 + i32.store + i32.const 20768 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 20768 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + i32.const 20780 + local.get $1 + i32.store + i32.const 20768 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 20768 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=12 + i32.const 20768 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 20816 + i32.const 166 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.lt_s + if + i64.const 0 + local.set $4 + i32.const 0 + local.set $3 + loop $for-loop|1 + local.get $3 + i32.const 8 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $4 + local.get $1 + local.get $2 + i32.const 3 + i32.shl + local.get $3 + i32.add + call $~lib/array/Array#__get + i64.extend_i32_u + local.get $3 + i32.const 3 + i32.shl + i32.const 255 + i32.and + i64.extend_i32_u + i64.shl + i64.or + local.set $4 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $2 + local.get $4 + call $~lib/staticarray/StaticArray#__set + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $assembly/program/liftBytes + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/program/deblob + local.tee $7 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 13 + call $~lib/staticarray/StaticArray#constructor + local.tee $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $5 + local.get $1 + call $assembly/api/fillRegisters + global.get $~lib/memory/__stack_pointer + call $assembly/memory/MemoryBuilder#constructor + local.tee $8 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=24 + block $__inlined_func$assembly/api/readPages$43 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 20880 + call $~lib/rt/__newArray + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + call $assembly/codec/Decoder#constructor + local.tee $2 + i32.store offset=8 + loop $while-continue|0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 48 + call $~lib/rt/itcms/__new + local.tee $9 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + call $~lib/object/Object#constructor + local.tee $9 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $9 + local.get $2 + call $assembly/codec/Decoder#u32 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $9 + local.get $2 + call $assembly/codec/Decoder#u32 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $9 + i32.const 2 + i32.const 1 + local.get $2 + call $assembly/codec/Decoder#u8 + select + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $1 + local.get $9 + call $~lib/array/Array#push + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + br $__inlined_func$assembly/api/readPages$43 + end + br $folding-inner1 + end + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 20912 + call $~lib/rt/__newArray + local.tee $10 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + call $assembly/codec/Decoder#constructor + local.tee $1 + i32.store offset=8 + loop $while-continue|01 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + call $assembly/api-generic/InitialChunk#constructor + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + local.get $2 + local.get $1 + call $assembly/codec/Decoder#u32 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $assembly/codec/Decoder#u32 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $11 + call $assembly/codec/Decoder#bytes + local.tee $6 + i32.store offset=20 + i32.const 0 + local.set $3 + loop $for-loop|1 + local.get $3 + local.get $11 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + local.tee $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=16 + local.get $12 + local.get $6 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#push + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $10 + local.get $2 + call $~lib/array/Array#push + br $while-continue|01 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=20 + local.get $8 + local.get $9 + local.get $10 + call $assembly/api-generic/buildMemory + local.tee $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $7 + local.get $5 + local.get $0 + call $assembly/interpreter/Interpreter#constructor + local.tee $0 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 + i32.store + local.get $1 + local.get $4 + call $assembly/gas/GasCounter#set@override + local.get $0 + global.set $assembly/api/interpreter + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api/nextStep (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 43 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + call $assembly/interpreter/Interpreter#nextStep + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $assembly/api/nSteps (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 51 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + i32.const 1 + local.set $2 + loop $for-loop|0 + local.get $0 + local.get $3 + i32.gt_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/interpreter/Interpreter#nextStep + local.tee $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $assembly/api/getProgramCounter (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 68 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/setNextProgramCounter (param $0 i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 76 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/getStatus (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 1 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 84 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=20 + i32.const 255 + i32.and + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/getExitArg (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 92 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=24 + local.tee $0 + i32.eqz + if + i32.const 0 + local.set $0 + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/api/getGasLeft (result i64) + (local $0 i32) + (local $1 i64) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + i64.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 100 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $0 + i32.store offset=8 + local.get $0 + call $assembly/gas/GasCounter#get@override + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/setGasLeft (param $0 i64) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 106 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=12 + local.tee $1 + i32.store offset=8 + local.get $1 + local.get $0 + call $assembly/gas/GasCounter#set@override + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/getRegisters (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 104 + call $~lib/typedarray/Uint8Array#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + i32.const 1 + global.set $~argumentsLength + local.get $3 + call $~lib/typedarray/Uint8Array#fill@varargs + local.tee $4 + i32.store offset=4 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 117 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.store offset=12 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=4 + local.tee $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + local.set $2 + i32.const 0 + local.set $0 + loop $for-loop|1 + local.get $0 + i32.const 8 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $1 + i32.const 3 + i32.shl + local.get $0 + i32.add + local.get $2 + i64.const 255 + i64.and + i32.wrap_i64 + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i64.const 8 + i64.shr_u + local.set $2 + local.get $0 + i32.const 1 + i32.add + local.set $0 + br $for-loop|1 + end + end + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/api/getPageDump (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api/interpreter + i32.eqz + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 142 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.tee $1 + i32.store + block $__inlined_func$assembly/memory/Memory#pageDump$2440 + local.get $1 + local.get $0 + call $"~lib/map/Map#has" + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + local.set $0 + br $__inlined_func$assembly/memory/Memory#pageDump$2440 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.tee $1 + i32.store offset=8 + local.get $1 + local.get $0 + call $"~lib/map/Map#get" + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + call $assembly/memory-page/RawPage#get:data + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + end + local.get $0 + i32.store offset=16 + local.get $0 + i32.eqz + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + i32.const 4096 + call $~lib/typedarray/Uint8Array#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 1 + global.set $~argumentsLength + local.get $0 + call $~lib/typedarray/Uint8Array#fill@varargs + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/object/Object#constructor (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/rt/__newArray (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.shl + local.tee $5 + i32.const 1 + call $~lib/rt/itcms/__new + local.set $1 + local.get $3 + if + local.get $1 + local.get $3 + local.get $5 + memory.copy + end + local.get $1 + i32.store + i32.const 16 + local.get $2 + call $~lib/rt/itcms/__new + local.tee $2 + local.get $1 + i32.store + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + local.get $2 + local.get $1 + i32.store offset=4 + local.get $2 + local.get $5 + i32.store offset=8 + local.get $2 + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/staticarray/StaticArray#constructor (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i32.const 1073741820 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 23 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/arraybuffer/ArrayBuffer#constructor (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i32.const 1073741820 + i32.gt_u + if + i32.const 9200 + i32.const 9248 + i32.const 52 + i32.const 43 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/util/number/utoa32 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $1 + i32.const 2 + i32.lt_s + local.get $1 + i32.const 36 + i32.gt_s + i32.or + if + i32.const 15632 + i32.const 15760 + i32.const 350 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15824 + return + end + local.get $1 + i32.const 10 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 100000 + i32.lt_u + if (result i32) + local.get $0 + i32.const 100 + i32.lt_u + if (result i32) + local.get $0 + i32.const 10 + i32.ge_u + i32.const 1 + i32.add + else + local.get $0 + i32.const 10000 + i32.ge_u + i32.const 3 + i32.add + local.get $0 + i32.const 1000 + i32.ge_u + i32.add + end + else + local.get $0 + i32.const 10000000 + i32.lt_u + if (result i32) + local.get $0 + i32.const 1000000 + i32.ge_u + i32.const 6 + i32.add + else + local.get $0 + i32.const 1000000000 + i32.ge_u + i32.const 8 + i32.add + local.get $0 + i32.const 100000000 + i32.ge_u + i32.add + end + end + local.tee $1 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + local.get $2 + local.get $0 + local.get $1 + call $~lib/util/number/utoa32_dec_lut + else + local.get $1 + i32.const 16 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 31 + local.get $0 + i32.clz + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.tee $1 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + local.get $0 + i64.extend_i32_u + local.set $3 + loop $while-continue|0 + local.get $1 + i32.const 2 + i32.ge_u + if + local.get $2 + local.get $1 + i32.const 2 + i32.sub + local.tee $1 + i32.const 1 + i32.shl + i32.add + local.get $3 + i32.wrap_i64 + i32.const 255 + i32.and + i32.const 2 + i32.shl + i32.const 16256 + i32.add + i32.load + i32.store + local.get $3 + i64.const 8 + i64.shr_u + local.set $3 + br $while-continue|0 + end + end + local.get $1 + i32.const 1 + i32.and + if + local.get $2 + local.get $3 + i32.wrap_i64 + i32.const 6 + i32.shl + i32.const 16256 + i32.add + i32.load16_u + i32.store16 + end + else + global.get $~lib/memory/__stack_pointer + block $__inlined_func$~lib/util/number/ulog_base$2258 (result i32) + local.get $0 + i64.extend_i32_u + local.set $4 + local.get $1 + i32.popcnt + i32.const 1 + i32.eq + if + i32.const 63 + local.get $4 + i64.clz + i32.wrap_i64 + i32.sub + i32.const 31 + local.get $1 + i32.clz + i32.sub + i32.div_u + i32.const 1 + i32.add + br $__inlined_func$~lib/util/number/ulog_base$2258 + end + local.get $1 + i64.extend_i32_s + local.tee $5 + local.set $3 + i32.const 1 + local.set $2 + loop $while-continue|01 + local.get $3 + local.get $4 + i64.le_u + if + local.get $4 + local.get $3 + i64.div_u + local.set $4 + local.get $3 + local.get $3 + i64.mul + local.set $3 + local.get $2 + i32.const 1 + i32.shl + local.set $2 + br $while-continue|01 + end + end + loop $while-continue|1 + local.get $4 + i64.const 0 + i64.ne + if + local.get $4 + local.get $5 + i64.div_u + local.set $4 + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $while-continue|1 + end + end + local.get $2 + i32.const 1 + i32.sub + end + local.tee $6 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + local.get $2 + local.get $0 + i64.extend_i32_u + local.get $6 + local.get $1 + call $~lib/util/number/utoa64_any_core + end + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/staticarray/StaticArray#constructor (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i32.const 134217727 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 3 + i32.shl + i32.const 14 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/util/number/utoa64 (param $0 i64) (param $1 i32) (result i32) + (local $2 i64) + (local $3 i32) + (local $4 i64) + (local $5 i64) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $1 + i32.const 2 + i32.lt_s + local.get $1 + i32.const 36 + i32.gt_s + i32.or + if + i32.const 15632 + i32.const 15760 + i32.const 401 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15824 + return + end + local.get $1 + i32.const 10 + i32.eq + if + local.get $0 + i64.const 4294967295 + i64.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.wrap_i64 + local.tee $1 + i32.const 100000 + i32.lt_u + if (result i32) + local.get $1 + i32.const 100 + i32.lt_u + if (result i32) + local.get $1 + i32.const 10 + i32.ge_u + i32.const 1 + i32.add + else + local.get $1 + i32.const 10000 + i32.ge_u + i32.const 3 + i32.add + local.get $1 + i32.const 1000 + i32.ge_u + i32.add + end + else + local.get $1 + i32.const 10000000 + i32.lt_u + if (result i32) + local.get $1 + i32.const 1000000 + i32.ge_u + i32.const 6 + i32.add + else + local.get $1 + i32.const 1000000000 + i32.ge_u + i32.const 8 + i32.add + local.get $1 + i32.const 100000000 + i32.ge_u + i32.add + end + end + local.tee $6 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + local.get $3 + local.get $1 + local.get $6 + call $~lib/util/number/utoa32_dec_lut + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i64.const 1000000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 1000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 100000000000 + i64.ge_u + i32.const 10 + i32.add + local.get $0 + i64.const 10000000000 + i64.ge_u + i32.add + else + local.get $0 + i64.const 100000000000000 + i64.ge_u + i32.const 13 + i32.add + local.get $0 + i64.const 10000000000000 + i64.ge_u + i32.add + end + else + local.get $0 + i64.const 100000000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 10000000000000000 + i64.ge_u + i32.const 16 + i32.add + else + local.get $0 + i64.const -8446744073709551616 + i64.ge_u + i32.const 18 + i32.add + local.get $0 + i64.const 1000000000000000000 + i64.ge_u + i32.add + end + end + local.tee $1 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + local.get $3 + local.get $0 + local.get $1 + call $~lib/util/number/utoa64_dec_lut + end + else + local.get $1 + i32.const 16 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 63 + local.get $0 + i64.clz + i32.wrap_i64 + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.tee $1 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + loop $while-continue|0 + local.get $1 + i32.const 2 + i32.ge_u + if + local.get $3 + local.get $1 + i32.const 2 + i32.sub + local.tee $1 + i32.const 1 + i32.shl + i32.add + local.get $0 + i32.wrap_i64 + i32.const 255 + i32.and + i32.const 2 + i32.shl + i32.const 16256 + i32.add + i32.load + i32.store + local.get $0 + i64.const 8 + i64.shr_u + local.set $0 + br $while-continue|0 + end + end + local.get $1 + i32.const 1 + i32.and + if + local.get $3 + local.get $0 + i32.wrap_i64 + i32.const 6 + i32.shl + i32.const 16256 + i32.add + i32.load16_u + i32.store16 + end + else + global.get $~lib/memory/__stack_pointer + block $__inlined_func$~lib/util/number/ulog_base$2264 (result i32) + local.get $0 + local.set $2 + local.get $1 + i32.popcnt + i32.const 1 + i32.eq + if + i32.const 63 + local.get $0 + i64.clz + i32.wrap_i64 + i32.sub + i32.const 31 + local.get $1 + i32.clz + i32.sub + i32.div_u + i32.const 1 + i32.add + br $__inlined_func$~lib/util/number/ulog_base$2264 + end + local.get $1 + i64.extend_i32_s + local.tee $5 + local.set $4 + i32.const 1 + local.set $3 + loop $while-continue|01 + local.get $2 + local.get $4 + i64.ge_u + if + local.get $2 + local.get $4 + i64.div_u + local.set $2 + local.get $4 + local.get $4 + i64.mul + local.set $4 + local.get $3 + i32.const 1 + i32.shl + local.set $3 + br $while-continue|01 + end + end + loop $while-continue|1 + local.get $2 + i64.const 0 + i64.ne + if + local.get $2 + local.get $5 + i64.div_u + local.set $2 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $while-continue|1 + end + end + local.get $3 + i32.const 1 + i32.sub + end + local.tee $6 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + local.get $3 + local.get $0 + local.get $6 + local.get $1 + call $~lib/util/number/utoa64_any_core + end + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/util/number/itoa64 (param $0 i64) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15824 + return + end + i64.const 0 + local.get $0 + i64.sub + local.get $0 + local.get $0 + i64.const 63 + i64.shr_u + i32.wrap_i64 + i32.const 1 + i32.shl + local.tee $1 + select + local.tee $0 + i64.const 4294967295 + i64.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.wrap_i64 + local.tee $4 + i32.const 100000 + i32.lt_u + if (result i32) + local.get $4 + i32.const 100 + i32.lt_u + if (result i32) + local.get $4 + i32.const 10 + i32.ge_u + i32.const 1 + i32.add + else + local.get $4 + i32.const 10000 + i32.ge_u + i32.const 3 + i32.add + local.get $4 + i32.const 1000 + i32.ge_u + i32.add + end + else + local.get $4 + i32.const 10000000 + i32.lt_u + if (result i32) + local.get $4 + i32.const 1000000 + i32.ge_u + i32.const 6 + i32.add + else + local.get $4 + i32.const 1000000000 + i32.ge_u + i32.const 8 + i32.add + local.get $4 + i32.const 100000000 + i32.ge_u + i32.add + end + end + local.tee $3 + i32.const 1 + i32.shl + local.get $1 + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + local.get $1 + local.get $2 + i32.add + local.get $4 + local.get $3 + call $~lib/util/number/utoa32_dec_lut + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i64.const 1000000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 1000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 100000000000 + i64.ge_u + i32.const 10 + i32.add + local.get $0 + i64.const 10000000000 + i64.ge_u + i32.add + else + local.get $0 + i64.const 100000000000000 + i64.ge_u + i32.const 13 + i32.add + local.get $0 + i64.const 10000000000000 + i64.ge_u + i32.add + end + else + local.get $0 + i64.const 100000000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 10000000000000000 + i64.ge_u + i32.const 16 + i32.add + else + local.get $0 + i64.const -8446744073709551616 + i64.ge_u + i32.const 18 + i32.add + local.get $0 + i64.const 1000000000000000000 + i64.ge_u + i32.add + end + end + local.tee $3 + i32.const 1 + i32.shl + local.get $1 + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + local.get $1 + local.get $2 + i32.add + local.get $0 + local.get $3 + call $~lib/util/number/utoa64_dec_lut + end + local.get $1 + if + local.get $2 + i32.const 45 + i32.store16 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $export:assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $assembly/index/disassemble + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/index/runProgram (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $__inlined_func$assembly/index/runProgram$2441 + local.get $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + call $assembly/api-generic/VmInput#constructor + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $2 + local.get $1 + i32.store + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i64.const 10000 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $2 + local.get $0 + i32.store offset=16 + local.get $2 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.const 1 + i32.const 0 + call $assembly/api-generic/runVm + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 19248 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + local.get $0 + i32.load + call $~lib/number/I32#toString + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + i32.const 19248 + local.get $1 + call $~lib/string/String#concat + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$assembly/index/runProgram$2441 + end + local.get $2 + i32.const 1 + i32.eq + if + i32.const 20224 + i32.const 20304 + i32.const 57 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 18608 + i32.store offset=4 + local.get $2 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 18608 + local.get $0 + call $~lib/string/String#concat + i32.const 20304 + i32.const 60 + i32.const 3 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api-generic/runVm@varargs (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $1 + end + i32.const 0 + local.set $2 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $assembly/api-generic/runVm + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api-generic/getAssembly (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/api-generic/getAssembly + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $assembly/program-build/buildMask + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i64.extend_i32_s + call $assembly/codec/encodeVarU32 + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + i32.const 2 + i32.add + local.get $2 + i32.add + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.get $2 + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + i32.const 2 + local.set $2 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $6 + local.get $2 + local.get $5 + local.get $4 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 1 + i32.add + local.set $2 + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + local.get $6 + local.get $2 + local.get $0 + local.get $1 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 1 + i32.add + local.set $2 + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|1 + end + end + i32.const 0 + local.set $0 + loop $for-loop|2 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.get $0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $6 + local.get $2 + local.get $3 + local.get $0 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 1 + i32.add + local.set $2 + local.get $0 + i32.const 1 + i32.add + local.set $0 + br $for-loop|2 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api/resetGeneric (param $0 i32) (param $1 i32) (param $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $assembly/program/liftBytes + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/program/deblob + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 13 + call $~lib/staticarray/StaticArray#constructor + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + call $assembly/api/fillRegisters + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 2 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + call $assembly/memory/MemoryBuilder#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + call $assembly/memory/MemoryBuilder#build + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + local.get $3 + local.get $0 + local.get $1 + call $assembly/interpreter/Interpreter#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 + i32.store + local.get $1 + local.get $2 + call $assembly/gas/GasCounter#set@override + local.get $0 + global.set $assembly/api/interpreter + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $0 + local.get $1 + local.get $2 + local.get $3 + local.get $4 + call $assembly/api/resetGenericWithMemory + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api/setRegisters (param $0 i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 134 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $1 + local.get $0 + call $assembly/api/fillRegisters + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api/setMemory (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 155 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $0 + i32.add + local.set $4 + local.get $0 + local.set $2 + loop $for-loop|0 + local.get $2 + local.get $4 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $5 + local.get $2 + local.get $1 + local.get $2 + local.get $0 + i32.sub + call $~lib/typedarray/Uint8Array#__get + call $assembly/memory/Memory#setU8 + drop + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) +) diff --git a/dist/test.d.ts b/dist/test.d.ts new file mode 100644 index 0000000..981d658 --- /dev/null +++ b/dist/test.d.ts @@ -0,0 +1,6 @@ +/** Exported memory */ +export declare const memory: WebAssembly.Memory; +/** + * assembly/test-run/runAllTests + */ +export declare function runAllTests(): void; diff --git a/dist/test.js b/dist/test.js new file mode 100644 index 0000000..7e2eb90 --- /dev/null +++ b/dist/test.js @@ -0,0 +1,47 @@ +async function instantiate(module, imports = {}) { + const adaptedImports = { + env: Object.setPrototypeOf({ + abort(message, fileName, lineNumber, columnNumber) { + // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void + message = __liftString(message >>> 0); + fileName = __liftString(fileName >>> 0); + lineNumber = lineNumber >>> 0; + columnNumber = columnNumber >>> 0; + (() => { + // @external.js + throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); + })(); + }, + "console.log"(text) { + // ~lib/bindings/dom/console.log(~lib/string/String) => void + text = __liftString(text >>> 0); + console.log(text); + }, + }, Object.assign(Object.create(globalThis), imports.env || {})), + }; + const { exports } = await WebAssembly.instantiate(module, adaptedImports); + const memory = exports.memory || imports.env.memory; + function __liftString(pointer) { + if (!pointer) return null; + const + end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, + memoryU16 = new Uint16Array(memory.buffer); + let + start = pointer >>> 1, + string = ""; + while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); + return string + String.fromCharCode(...memoryU16.subarray(start, end)); + } + return exports; +} +export const { + memory, + runAllTests, +} = await (async url => instantiate( + await (async () => { + const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); + if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } + else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } + })(), { + } +))(new URL("test.wasm", import.meta.url)); diff --git a/dist/test.wasm b/dist/test.wasm new file mode 100644 index 0000000000000000000000000000000000000000..c893f4016987ad4e9d4a65e843c78c478f6a08af GIT binary patch literal 189597 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 LesDH?H17WaNe@@g literal 0 HcmV?d00001 diff --git a/dist/test.wasm.map b/dist/test.wasm.map new file mode 100644 index 0000000..af2d1b3 --- /dev/null +++ b/dist/test.wasm.map @@ -0,0 +1 @@ +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/bit.test.ts","~lib/util/hash.ts","~lib/map.ts","~lib/array.ts","assembly/test.ts","~lib/number.ts","~lib/string.ts","assembly/instructions/branch.ts","assembly/instructions/branch.test.ts","assembly/instructions/logic.ts","assembly/instructions/logic.test.ts","assembly/instructions/math.ts","assembly/instructions/math.test.ts","assembly/instructions/rot.ts","assembly/instructions/rot.test.ts","assembly/memory.test.ts","~lib/util/bytes.ts","~lib/console.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","assembly/instructions/mov.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions/misc.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/instructions.ts","assembly/program.ts","assembly/program.test.ts","assembly/spi.ts","assembly/spi.test.ts","assembly/test-run.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./test","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2dad002dad00?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16;\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = SEGMENT_SIZE;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport {\n count_set_bits_32,\n count_set_bits_64,\n leading_zero_bits_32,\n leading_zero_bits_64,\n reverse_bytes,\n sign_extend_8,\n sign_extend_16,\n trailing_zero_bits_32,\n trailing_zero_bits_64,\n zero_extend_16,\n} from \"./bit\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"count_set_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 2 * 8 + 4);\n return assert;\n }),\n test(\"count_set_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 4);\n return assert;\n }),\n test(\"leading_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 16);\n return assert;\n }),\n test(\"leading_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 19);\n return assert;\n }),\n test(\"trailing_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 36);\n return assert;\n }),\n test(\"trailing_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 32);\n return assert;\n }),\n test(\"sign_extend_8\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_8(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_ffef);\n return assert;\n }),\n test(\"sign_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_beef);\n return assert;\n }),\n test(\"zero_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = zero_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0x0000_beef);\n return assert;\n }),\n test(\"reverse_bytes\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_dead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = reverse_bytes(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xefbe_adde_f0ff_0000);\n return assert;\n }),\n];\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","export class Test {\n constructor(\n public name: string,\n public ptr: (assert: Assert) => Assert,\n ) {}\n}\n\nexport class Assert {\n public isOkay: boolean = true;\n public errors: string[] = [];\n\n static todo(): Assert {\n const r = new Assert();\n r.fail(\"Not implemented yet!\");\n return r;\n }\n\n fail(msg: string): void {\n this.isOkay = false;\n this.errors.push(msg);\n }\n\n isArrayEqual(actual: T[], expected: T[], msg: string = \"\"): void {\n this.isEqual(actual.length, expected.length, `length @ ${msg}`);\n this.isEqual(actual.join(\",\").toString(), expected.join(\",\").toString(), msg);\n }\n\n isEqual(actual: T, expected: T, msg: string = \"\"): void {\n if (actual !== expected) {\n this.isOkay = false;\n const actualDisplay = isInteger(actual) ? `${actual} (0x${actual.toString(16)})` : `${actual}`;\n const expectDisplay = isInteger(expected) ? `${expected} (0x${expected.toString(16)})` : `${expected}`;\n this.errors.push(`Got: '${actualDisplay}', expected: '${expectDisplay}' @ ${msg}`);\n }\n }\n}\n\nexport function test(name: string, ptr: (assert: Assert) => Assert): Test {\n return new Test(name, ptr);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { branch_eq_imm } from \"./branch\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"branch_eq_imm\", () => {\n // when\n const args = new Args();\n args.a = 0;\n args.b = 0xfe;\n args.c = 0xdeadbeef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfe;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = branch_eq_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.StaticJump, \"outcome\");\n assert.isEqual(ret.staticJump, 0xdeadbeef, \"staticJump\");\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { and_inv, or_inv, xnor } from \"./logic\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"and_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = and_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_f000_0000_0000);\n return assert;\n }),\n test(\"or_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = or_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fff1);\n return assert;\n }),\n test(\"xnor\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0000;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = xnor(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_0fff_ffff_fff0);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport * as math from \"./math\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"max\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"max_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"add_32\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = 2 ** 64 - 1;\n regs[reg(args.b)] = 2 ** 64 - 1;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.add_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fffe);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { Outcome } from \"./outcome\";\nimport { rot_l_32, rot_l_64, rot_r_64_imm, rot_r_64_imm_alt } from \"./rot\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"rot_r_64_imm\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xef00_0000_00de_adbe);\n return assert;\n }),\n test(\"rot_r_64_imm_alt\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0xdead_beef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm_alt(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xefff_ffff_ffde_adbe);\n return assert;\n }),\n test(\"rot_l_64\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_00de_adbe_ef00);\n return assert;\n }),\n test(\"rot_l_32\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_adbe_efde);\n return assert;\n }),\n];\n","import { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY, RESERVED_PAGES } from \"./memory-page\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"Show fail when accessing any of the initial 16 pages\", () => {\n const mem = new MemoryBuilder().build();\n\n const a = mem.getI8(0);\n const b = mem.getU64(RESERVED_MEMORY - 1);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, true, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.fault.fault, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 61440);\n return assert;\n }),\n test(\"Show fail on missing page or invalid access\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Read, RESERVED_MEMORY, new Uint8Array(10));\n const mem = builder.build();\n\n const a = mem.getU64(RESERVED_MEMORY);\n const b = mem.getU8((RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT);\n const c = mem.setU8(RESERVED_MEMORY, 12);\n const d = mem.getU8(RESERVED_MEMORY);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, false, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.ok, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 69632);\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, true, \"c.access\");\n assert.isEqual(c.fault, 65536);\n assert.isEqual(d.ok, 0);\n return assert;\n }),\n test(\"should read and write across pages\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Write, RESERVED_MEMORY, new Uint8Array(1));\n builder.setData(Access.Write, (RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT, new Uint8Array(1));\n const mem = builder.build();\n\n const out = new Uint8Array(16);\n const data = new Uint8Array(out.length);\n data.set([0xde, 0xad, 0xbe, 0xef], 0);\n\n const a = mem.bytesWrite(RESERVED_MEMORY + PAGE_SIZE - 10, data);\n const b = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE - 9, out);\n const c = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE * 2, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(a.isAccess, false, \"a.access\");\n assert.isEqual(a.fault, 0, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(b.isAccess, false, \"b.access\");\n assert.isEqual(b.fault, 0, \"b.fault\");\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, false, \"c.access\");\n assert.isEqual(out.toString(), \"173,190,239,0,0,0,0,0,0,0,0,0,0,0,0,0\");\n assert.isEqual(data.toString(), \"222,173,190,239,0,0,0,0,0,0,0,0,0,0,0,0\");\n return assert;\n }),\n test(\"should allow 0-bytes reads and writes everywhere\", () => {\n const mem = new MemoryBuilder().setData(Access.Read, RESERVED_MEMORY, new Uint8Array(0)).build();\n\n const out = new Uint8Array(0);\n\n // reserved pages\n const a = mem.bytesRead(0, out);\n const b = mem.bytesWrite(0, out);\n\n // not allocated\n const c = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n const d = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n\n // readable page\n const e = mem.bytesWrite(RESERVED_MEMORY, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(c.isFault, false, \"c.fault\");\n assert.isEqual(d.isFault, false, \"d.fault\");\n assert.isEqual(e.isFault, false, \"e.fault\");\n return assert;\n }),\n];\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { Arguments } from \"./arguments\";\nimport { RUN } from \"./instructions-exe\";\nimport { jump_ind } from \"./instructions/jump\";\nimport { trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport { BasicBlocks, JumpTable, Mask, deblob, decodeArguments } from \"./program\";\nimport { Assert, Test, test } from \"./test\";\n\nexport function u8arr(data: number[]): Uint8Array {\n const ret = new Uint8Array(data.length);\n ret.set(data, 0);\n return ret;\n}\n\nexport const TESTS: Test[] = [\n test(\"should parse packed mask correctly\", () => {\n const mask = new Mask(u8arr([0b0001_0000, 0b1000_0000, 0b1111_1000]), 21);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [4, 3, 2, 1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 3, 2, 1, 0, 0],\n );\n\n assert.isEqual(mask.isInstruction(0), false);\n assert.isEqual(mask.isInstruction(4), true);\n\n assert.isEqual(mask.skipBytesToNextInstruction(20), 0);\n assert.isEqual(mask.skipBytesToNextInstruction(22), 0);\n return assert;\n }),\n\n test(\"should not allow skipping more than 24 bytes\", () => {\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [\n 0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,\n 1, 0,\n ],\n );\n return assert;\n }),\n\n test(\"should decode arguments correctly\", () => {\n const data = u8arr([0xff, 0xff, 0xff, 0xff]);\n const args = decodeArguments(Arguments.OneImm, data, 4);\n\n const assert = new Assert();\n assert.isEqual(args.a, -1, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should decode positive bounded by skip\", () => {\n const data = u8arr([0x05, 0x05]);\n const args = decodeArguments(Arguments.OneImm, data, 1);\n\n const assert = new Assert();\n assert.isEqual(args.a, 5, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should deblob program\", () => {\n const raw = u8arr([\n 0, 0, 33, 51, 8, 1, 51, 9, 1, 40, 3, 0, 149, 119, 255, 81, 7, 12, 100, 138, 200, 152, 8, 100, 169, 40, 243, 100,\n 135, 51, 8, 51, 9, 1, 50, 0, 73, 147, 82, 213, 0,\n ]);\n const program = deblob(raw);\n const assert = new Assert();\n assert.isEqual(\n program.mask.toString(),\n \"Mask[0, 2, 1, 0, 2, 1, 0, 1, 0, 0, 2, 1, 0, 2, 1, 0, 1, 0, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, ]\",\n );\n assert.isEqual(program.jumpTable.toString(), \"JumpTable[]\");\n assert.isEqual(\n program.basicBlocks.toString(),\n \"BasicBlocks[0 -> start, 6 -> end, 8 -> startend, 9 -> start, 12 -> end, 15 -> start, 22 -> end, 24 -> start, 30 -> end, 31 -> startend, ]\",\n );\n return assert;\n }),\n\n test(\"should construct basic blocks correctly based on skip\", () => {\n const code = u8arr([\n opcode(trap),\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n opcode(jump_ind),\n ]);\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n const basicBlocks = new BasicBlocks(code, mask);\n const assert = new Assert();\n assert.isEqual(\n mask.toString(),\n \"Mask[0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, ]\",\n );\n assert.isEqual(basicBlocks.toString(), \"BasicBlocks[0 -> startend, 26 -> start, 31 -> end, ]\");\n return assert;\n }),\n test(\"should parse jump table with large numbers\", () => {\n const jumpTable = new JumpTable(\n 10,\n u8arr([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 2, 2, 2, 0]),\n );\n const assert = new Assert();\n assert.isEqual(\n jumpTable.toString(),\n \"JumpTable[0 -> 18446744073709551615, 1 -> 18446744073709551615, 2 -> 18446744073709551615, ]\",\n );\n return assert;\n }),\n];\n\nfunction opcode(search: InstructionRun): number {\n const idx = RUN.indexOf(search);\n if (idx < 0) {\n throw new Error(\"Opcode not found in RUN table for instruction\");\n }\n return idx;\n}\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { Program, deblob } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const DATA_LENGTH: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - DATA_LENGTH;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = 2 ** 32 - 2 * SEGMENT_SIZE - DATA_LENGTH;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > DATA_LENGTH) {\n throw new Error(\"Arguments length too big\");\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { liftBytes } from \"./program\";\nimport { decodeSpi } from \"./spi\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"should decode standard program\", () => {\n const PROGRAM = liftBytes([\n 0x04, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0xab, 0xcd, 0xef, 0x01, 0x12, 0x34, 0x07, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x03, 0xc8, 0x87, 0x09, 0x01,\n ]);\n const ARGS = liftBytes([0x12, 0x34, 0x56]);\n\n const spi = decodeSpi(PROGRAM, ARGS);\n\n const assert = new Assert();\n assert.isEqual(\n spi.toString(),\n \"StandardProgram { program: Program { code: 200,135,9, mask: Mask[0, 2, 1, ], jumpTable: JumpTable[], basicBlocks: BasicBlocks[0 -> start, ] }, memory_pages: 7, registers: 4294901760,4278059008,0,0,0,0,0,4278124544,3,0,0,0,0 }\",\n );\n return assert;\n }),\n];\n","import * as bit from \"./instructions/bit.test\";\nimport * as branch from \"./instructions/branch.test\";\nimport * as logic from \"./instructions/logic.test\";\nimport * as math from \"./instructions/math.test\";\nimport * as rot from \"./instructions/rot.test\";\nimport * as memory from \"./memory.test\";\nimport * as program from \"./program.test\";\nimport * as spi from \"./spi.test\";\nimport { Assert, Test } from \"./test\";\n\nexport function runAllTests(): void {\n let a: u64 = 0;\n\n a += run(bit.TESTS, \"bit.ts\");\n a += run(branch.TESTS, \"branch.ts\");\n a += run(logic.TESTS, \"logic.ts\");\n a += run(math.TESTS, \"math.ts\");\n a += run(memory.TESTS, \"memory.ts\");\n a += run(program.TESTS, \"program.ts\");\n a += run(rot.TESTS, \"rot.ts\");\n a += run(spi.TESTS, \"spi.ts\");\n\n const okay = u32(a >> 32);\n const total = u32(a);\n\n printSummary(\"\\n\\nTotal\", okay, total);\n if (okay !== total) {\n throw new Error(\"Some tests failed.\");\n }\n}\n\nfunction run(tests: Test[], file: string): u64 {\n let ok = 0;\n console.log(`> ${file}`);\n for (let i = 0; i < tests.length; i++) {\n console.log(` >>> ${tests[i].name}`);\n const res = tests[i].ptr(new Assert());\n if (res.isOkay) {\n console.log(` <<< ${tests[i].name} ✅`);\n ok += 1;\n } else {\n for (let j = 0; j < res.errors.length; j++) {\n console.log(` ${res.errors[j]}`);\n }\n console.log(` <<< ${tests[i].name} 🔴`);\n }\n }\n\n printSummary(`< ${file}`, ok, tests.length);\n\n return (u64(ok) << 32) + tests.length;\n}\n\nfunction printSummary(msg: string, okay: u32, total: u32): void {\n const ico = okay === total ? \"✅\" : \"🔴\";\n console.log(`${msg} ${okay} / ${total} ${ico}`);\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/dist/test.wat b/dist/test.wat new file mode 100644 index 0000000..c8dd9d6 --- /dev/null +++ b/dist/test.wat @@ -0,0 +1,45369 @@ +(module + (type $0 (func (param i32) (result i32))) + (type $1 (func (param i32 i32 i32) (result i32))) + (type $2 (func (param i32 i32))) + (type $3 (func (param i32 i32) (result i32))) + (type $4 (func)) + (type $5 (func (param i32 i32 i32))) + (type $6 (func (param i32 i32 i32 i32) (result i32))) + (type $7 (func (param i32))) + (type $8 (func (param i32 i32 i32 i32))) + (type $9 (func (param i64 i64) (result i64))) + (type $10 (func (param i64 i32) (result i32))) + (type $11 (func (result i32))) + (type $12 (func (param i32) (result i64))) + (type $13 (func (param i32 i64))) + (type $14 (func (param i32 i32 i64) (result i32))) + (type $15 (func (param i64) (result i32))) + (type $16 (func (param i32 i32 i64))) + (type $17 (func (param i32 i64 i32))) + (type $18 (func (param i32 i32 i32 i32 i32) (result i32))) + (type $19 (func (param i32 i32) (result i64))) + (type $20 (func (param i32 i64 i64 i32))) + (type $21 (func (param i64) (result i64))) + (type $22 (func (param i32 i64 i32 i32))) + (type $23 (func (param i32 i32 i32 i32 i32))) + (type $24 (func (param i32 i32 i64 i32) (result i32))) + (type $25 (func (param i32 i64) (result i32))) + (type $26 (func (param i32) (result f64))) + (type $27 (func (param i32 i32 f64))) + (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) + (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) + (global $assembly/arguments/Arguments.Zero i32 (i32.const 0)) + (global $assembly/arguments/Arguments.OneImm i32 (i32.const 1)) + (global $assembly/arguments/Arguments.TwoImm i32 (i32.const 2)) + (global $assembly/arguments/Arguments.OneOff i32 (i32.const 3)) + (global $assembly/arguments/Arguments.OneRegOneImm i32 (i32.const 4)) + (global $assembly/arguments/Arguments.OneRegOneExtImm i32 (i32.const 5)) + (global $assembly/arguments/Arguments.OneRegTwoImm i32 (i32.const 6)) + (global $assembly/arguments/Arguments.OneRegOneImmOneOff i32 (i32.const 7)) + (global $assembly/arguments/Arguments.TwoReg i32 (i32.const 8)) + (global $assembly/arguments/Arguments.TwoRegOneImm i32 (i32.const 9)) + (global $assembly/arguments/Arguments.TwoRegOneOff i32 (i32.const 10)) + (global $assembly/arguments/Arguments.TwoRegTwoImm i32 (i32.const 11)) + (global $assembly/arguments/Arguments.ThreeReg i32 (i32.const 12)) + (global $assembly/arguments/RELEVANT_ARGS i32 (i32.const 112)) + (global $assembly/arguments/REQUIRED_BYTES i32 (i32.const 240)) + (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) + (global $~lib/shared/runtime/Runtime.Stub i32 (i32.const 0)) + (global $~lib/shared/runtime/Runtime.Minimal i32 (i32.const 1)) + (global $~lib/shared/runtime/Runtime.Incremental i32 (i32.const 2)) + (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) + (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) + (global $~lib/native/ASC_LOW_MEMORY_LIMIT i32 (i32.const 0)) + (global $~lib/builtins/i32.MAX_VALUE i32 (i32.const 2147483647)) + (global $~argumentsLength (mut i32) (i32.const 0)) + (global $assembly/arguments/DECODERS i32 (i32.const 1248)) + (global $assembly/registers/NO_OF_REGISTERS i32 (i32.const 13)) + (global $assembly/registers/REG_SIZE_BYTES i32 (i32.const 8)) + (global $assembly/memory-page/PAGE_SIZE i32 (i32.const 4096)) + (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) + (global $~lib/native/ASC_SHRINK_LEVEL i32 (i32.const 0)) + (global $assembly/memory-page/SEGMENT_SIZE (mut i32) (i32.const 0)) + (global $assembly/memory-page/SEGMENT_SIZE_SHIFT i32 (i32.const 16)) + (global $assembly/memory-page/RESERVED_MEMORY (mut i32) (i32.const 0)) + (global $assembly/memory-page/RESERVED_PAGES (mut i32) (i32.const 0)) + (global $assembly/memory-page/ALLOCATE_EAGERLY (mut i32) (i32.const 0)) + (global $assembly/memory-page/Access.None i32 (i32.const 0)) + (global $assembly/memory-page/Access.Read i32 (i32.const 1)) + (global $assembly/memory-page/Access.Write i32 (i32.const 2)) + (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) + (global $assembly/memory/MEMORY_SIZE i64 (i64.const 4294967296)) + (global $~lib/native/ASC_RUNTIME i32 (i32.const 2)) + (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) + (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) + (global $assembly/instructions/outcome/Result.PANIC i32 (i32.const 0)) + (global $assembly/instructions/outcome/Result.FAULT i32 (i32.const 1)) + (global $assembly/instructions/outcome/Result.FAULT_ACCESS i32 (i32.const 2)) + (global $assembly/instructions/outcome/Result.HOST i32 (i32.const 3)) + (global $assembly/instructions/outcome/Outcome.Ok i32 (i32.const 0)) + (global $assembly/instructions/outcome/Outcome.StaticJump i32 (i32.const 1)) + (global $assembly/instructions/outcome/Outcome.DynamicJump i32 (i32.const 2)) + (global $assembly/instructions/outcome/Outcome.Result i32 (i32.const 3)) + (global $assembly/instructions/bit/count_set_bits_64 i32 (i32.const 1472)) + (global $assembly/instructions/bit/count_set_bits_32 i32 (i32.const 1504)) + (global $assembly/instructions/bit/leading_zero_bits_64 i32 (i32.const 1536)) + (global $assembly/instructions/bit/leading_zero_bits_32 i32 (i32.const 1568)) + (global $assembly/instructions/bit/trailing_zero_bits_64 i32 (i32.const 1600)) + (global $assembly/instructions/bit/trailing_zero_bits_32 i32 (i32.const 1632)) + (global $assembly/instructions/bit/sign_extend_8 i32 (i32.const 1664)) + (global $assembly/instructions/bit/sign_extend_16 i32 (i32.const 1696)) + (global $assembly/instructions/bit/zero_extend_16 i32 (i32.const 1728)) + (global $assembly/instructions/bit/reverse_bytes i32 (i32.const 1760)) + (global $~lib/builtins/u32.MAX_VALUE i32 (i32.const -1)) + (global $assembly/instructions/bit.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/instructions/branch/branch_eq_imm i32 (i32.const 5440)) + (global $assembly/instructions/branch/branch_ne_imm i32 (i32.const 5472)) + (global $assembly/instructions/branch/branch_lt_u_imm i32 (i32.const 5504)) + (global $assembly/instructions/branch/branch_le_u_imm i32 (i32.const 5536)) + (global $assembly/instructions/branch/branch_ge_u_imm i32 (i32.const 5568)) + (global $assembly/instructions/branch/branch_gt_u_imm i32 (i32.const 5600)) + (global $assembly/instructions/branch/branch_lt_s_imm i32 (i32.const 5632)) + (global $assembly/instructions/branch/branch_le_s_imm i32 (i32.const 5664)) + (global $assembly/instructions/branch/branch_ge_s_imm i32 (i32.const 5696)) + (global $assembly/instructions/branch/branch_gt_s_imm i32 (i32.const 5728)) + (global $assembly/instructions/branch/branch_eq i32 (i32.const 5760)) + (global $assembly/instructions/branch/branch_ne i32 (i32.const 5792)) + (global $assembly/instructions/branch/branch_lt_u i32 (i32.const 5824)) + (global $assembly/instructions/branch/branch_lt_s i32 (i32.const 5856)) + (global $assembly/instructions/branch/branch_ge_u i32 (i32.const 5888)) + (global $assembly/instructions/branch/branch_ge_s i32 (i32.const 5920)) + (global $assembly/instructions/branch.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/instructions/logic/and_imm i32 (i32.const 6224)) + (global $assembly/instructions/logic/xor_imm i32 (i32.const 6256)) + (global $assembly/instructions/logic/or_imm i32 (i32.const 6288)) + (global $assembly/instructions/logic/and i32 (i32.const 6320)) + (global $assembly/instructions/logic/xor i32 (i32.const 6352)) + (global $assembly/instructions/logic/or i32 (i32.const 6384)) + (global $assembly/instructions/logic/and_inv i32 (i32.const 6416)) + (global $assembly/instructions/logic/or_inv i32 (i32.const 6448)) + (global $assembly/instructions/logic/xnor i32 (i32.const 6480)) + (global $assembly/instructions/logic.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/instructions/math/add_imm_32 i32 (i32.const 6720)) + (global $assembly/instructions/math/mul_imm_32 i32 (i32.const 6752)) + (global $assembly/instructions/math/neg_add_imm_32 i32 (i32.const 6784)) + (global $assembly/instructions/math/add_imm i32 (i32.const 6816)) + (global $assembly/instructions/math/mul_imm i32 (i32.const 6848)) + (global $assembly/instructions/math/neg_add_imm i32 (i32.const 6880)) + (global $assembly/instructions/math/add_32 i32 (i32.const 6912)) + (global $assembly/instructions/math/sub_32 i32 (i32.const 6944)) + (global $assembly/instructions/math/mul_32 i32 (i32.const 6976)) + (global $~lib/builtins/u64.MAX_VALUE i64 (i64.const -1)) + (global $assembly/instructions/math/div_u_32 i32 (i32.const 7008)) + (global $~lib/builtins/i32.MIN_VALUE i32 (i32.const -2147483648)) + (global $assembly/instructions/math/div_s_32 i32 (i32.const 7040)) + (global $assembly/instructions/math/rem_u_32 i32 (i32.const 7072)) + (global $assembly/instructions/math/rem_s_32 i32 (i32.const 7104)) + (global $assembly/instructions/math/add_64 i32 (i32.const 7136)) + (global $assembly/instructions/math/sub i32 (i32.const 7168)) + (global $assembly/instructions/math/mul i32 (i32.const 7200)) + (global $assembly/instructions/math/div_u i32 (i32.const 7232)) + (global $~lib/builtins/i64.MIN_VALUE i64 (i64.const -9223372036854775808)) + (global $assembly/instructions/math/div_s i32 (i32.const 7264)) + (global $assembly/instructions/math/rem_u i32 (i32.const 7296)) + (global $assembly/instructions/math/rem_s i32 (i32.const 7328)) + (global $assembly/instructions/math/mul_upper_s_s i32 (i32.const 7360)) + (global $assembly/instructions/math/mul_upper_u_u i32 (i32.const 7392)) + (global $assembly/instructions/math/mul_upper_s_u i32 (i32.const 7424)) + (global $assembly/instructions/math/max i32 (i32.const 7456)) + (global $assembly/instructions/math/max_u i32 (i32.const 7488)) + (global $assembly/instructions/math/min i32 (i32.const 7520)) + (global $assembly/instructions/math/min_u i32 (i32.const 7552)) + (global $assembly/instructions/math.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/instructions/rot/rot_r_64_imm i32 (i32.const 7904)) + (global $assembly/instructions/rot/rot_r_64_imm_alt i32 (i32.const 7936)) + (global $assembly/instructions/rot/rot_r_32_imm i32 (i32.const 7968)) + (global $assembly/instructions/rot/rot_r_32_imm_alt i32 (i32.const 8000)) + (global $assembly/instructions/rot/rot_l_64 i32 (i32.const 8032)) + (global $assembly/instructions/rot/rot_l_32 i32 (i32.const 8064)) + (global $assembly/instructions/rot/rot_r_64 i32 (i32.const 8096)) + (global $assembly/instructions/rot/rot_r_32 i32 (i32.const 8128)) + (global $assembly/instructions/rot.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/memory.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/instructions/jump/jump i32 (i32.const 10576)) + (global $assembly/instructions/jump/jump_ind i32 (i32.const 10608)) + (global $assembly/instructions/jump/load_imm_jump i32 (i32.const 10640)) + (global $assembly/instructions/jump/load_imm_jump_ind i32 (i32.const 10672)) + (global $assembly/instructions/load/load_imm_64 i32 (i32.const 10704)) + (global $assembly/instructions/load/load_imm i32 (i32.const 10736)) + (global $assembly/instructions/load/load_u8 i32 (i32.const 10768)) + (global $assembly/instructions/load/load_i8 i32 (i32.const 10800)) + (global $assembly/instructions/load/load_u16 i32 (i32.const 10832)) + (global $assembly/instructions/load/load_i16 i32 (i32.const 10864)) + (global $assembly/instructions/load/load_u32 i32 (i32.const 10896)) + (global $assembly/instructions/load/load_i32 i32 (i32.const 10928)) + (global $assembly/instructions/load/load_u64 i32 (i32.const 10960)) + (global $assembly/instructions/load/load_ind_u8 i32 (i32.const 10992)) + (global $assembly/instructions/load/load_ind_i8 i32 (i32.const 11024)) + (global $assembly/instructions/load/load_ind_u16 i32 (i32.const 11056)) + (global $assembly/instructions/load/load_ind_i16 i32 (i32.const 11088)) + (global $assembly/instructions/load/load_ind_u32 i32 (i32.const 11120)) + (global $assembly/instructions/load/load_ind_i32 i32 (i32.const 11152)) + (global $assembly/instructions/load/load_ind_u64 i32 (i32.const 11184)) + (global $assembly/instructions/mov/move_reg i32 (i32.const 11216)) + (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11248)) + (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11280)) + (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11312)) + (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11344)) + (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 11376)) + (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 11408)) + (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 11440)) + (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 11472)) + (global $assembly/instructions/set/set_lt_u i32 (i32.const 11504)) + (global $assembly/instructions/set/set_lt_s i32 (i32.const 11536)) + (global $assembly/instructions/shift/MAX_SHIFT_64 i32 (i32.const 64)) + (global $assembly/instructions/shift/MAX_SHIFT_32 i32 (i32.const 32)) + (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 11568)) + (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 11600)) + (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 11632)) + (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 11664)) + (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 11696)) + (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 11728)) + (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 11760)) + (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 11792)) + (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 11824)) + (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 11856)) + (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 11888)) + (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 11920)) + (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 11952)) + (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 11984)) + (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12016)) + (global $assembly/instructions/shift/shlo_l i32 (i32.const 12048)) + (global $assembly/instructions/shift/shlo_r i32 (i32.const 12080)) + (global $assembly/instructions/shift/shar_r i32 (i32.const 12112)) + (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12144)) + (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12176)) + (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12208)) + (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12240)) + (global $assembly/instructions/store/store_u8 i32 (i32.const 12272)) + (global $assembly/instructions/store/store_u16 i32 (i32.const 12304)) + (global $assembly/instructions/store/store_u32 i32 (i32.const 12336)) + (global $assembly/instructions/store/store_u64 i32 (i32.const 12368)) + (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 12400)) + (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 12432)) + (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 12464)) + (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 12496)) + (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 12528)) + (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 12560)) + (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 12592)) + (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 12624)) + (global $assembly/instructions/misc/INVALID i32 (i32.const 12656)) + (global $assembly/instructions/misc/trap i32 (i32.const 12688)) + (global $assembly/instructions/misc/fallthrough i32 (i32.const 12720)) + (global $assembly/instructions/misc/ecalli i32 (i32.const 12752)) + (global $assembly/instructions/misc/sbrk i32 (i32.const 12784)) + (global $assembly/instructions-exe/RUN i32 (i32.const 13760)) + (global $assembly/codec/MASKS i32 (i32.const 13840)) + (global $assembly/codec/variableLength i32 (i32.const 13888)) + (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) + (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) + (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) + (global $assembly/program/MAX_SKIP i32 (i32.const 24)) + (global $assembly/program/BasicBlock.NONE i32 (i32.const 0)) + (global $assembly/program/BasicBlock.START i32 (i32.const 2)) + (global $assembly/program/BasicBlock.END i32 (i32.const 4)) + (global $assembly/program.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/spi/DATA_LENGTH (mut i32) (i32.const 0)) + (global $assembly/spi/ARGS_SEGMENT_START (mut i32) (i32.const 0)) + (global $assembly/spi/STACK_SEGMENT_END (mut i32) (i32.const 0)) + (global $assembly/spi.test/TESTS (mut i32) (i32.const 0)) + (global $~lib/rt/__rtti_base i32 (i32.const 27856)) + (global $~lib/memory/__data_end i32 (i32.const 28052)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 60820)) + (global $~lib/memory/__heap_base i32 (i32.const 60820)) + (memory $0 1) + (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") + (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $2 (i32.const 140) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") + (data $3 (i32.const 220) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00\a0\00\00\00\a0\00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $4 (i32.const 268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e\00\00\00\00\00") + (data $5 (i32.const 332) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $6 (i32.const 400) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $7 (i32.const 432) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $8 (i32.const 460) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e\00\00\00\00\00\00\00\00\00") + (data $9 (i32.const 524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $10 (i32.const 576) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $11 (i32.const 604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $12 (i32.const 668) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00") + (data $13 (i32.const 700) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $14 (i32.const 764) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") + (data $15 (i32.const 796) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") + (data $16 (i32.const 828) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\04\00\00\00\00\00\00\00\00\00\00\00") + (data $17 (i32.const 860) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\05\00\00\00\00\00\00\00\00\00\00\00") + (data $18 (i32.const 892) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\06\00\00\00\00\00\00\00\00\00\00\00") + (data $19 (i32.const 924) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\07\00\00\00\00\00\00\00\00\00\00\00") + (data $20 (i32.const 956) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00") + (data $21 (i32.const 988) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\t\00\00\00\00\00\00\00\00\00\00\00") + (data $22 (i32.const 1020) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") + (data $23 (i32.const 1052) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0b\00\00\00\00\00\00\00\00\00\00\00") + (data $24 (i32.const 1084) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0c\00\00\00\00\00\00\00\00\00\00\00") + (data $25 (i32.const 1116) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00") + (data $26 (i32.const 1148) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\b0\02\00\00\10\03\00\000\03\00\00P\03\00\00p\03\00\00\90\03\00\00\b0\03\00\00\d0\03\00\00\f0\03\00\00\10\04\00\000\04\00\00P\04\00\00p\04\00\00\00\00\00\00\00\00\00\00") + (data $27 (i32.const 1228) ",\00\00\00\00\00\00\00\00\00\00\00\07\00\00\00\10\00\00\00\90\04\00\00\90\04\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $28 (i32.const 1276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h\00") + (data $29 (i32.const 1324) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") + (data $30 (i32.const 1388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00") + (data $31 (i32.const 1452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\0e\00\00\00\00\00\00\00\00\00\00\00") + (data $32 (i32.const 1484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\0f\00\00\00\00\00\00\00\00\00\00\00") + (data $33 (i32.const 1516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\10\00\00\00\00\00\00\00\00\00\00\00") + (data $34 (i32.const 1548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\11\00\00\00\00\00\00\00\00\00\00\00") + (data $35 (i32.const 1580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\12\00\00\00\00\00\00\00\00\00\00\00") + (data $36 (i32.const 1612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\13\00\00\00\00\00\00\00\00\00\00\00") + (data $37 (i32.const 1644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\14\00\00\00\00\00\00\00\00\00\00\00") + (data $38 (i32.const 1676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\15\00\00\00\00\00\00\00\00\00\00\00") + (data $39 (i32.const 1708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\16\00\00\00\00\00\00\00\00\00\00\00") + (data $40 (i32.const 1740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\17\00\00\00\00\00\00\00\00\00\00\00") + (data $41 (i32.const 1772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00c\00o\00u\00n\00t\00_\00s\00e\00t\00_\00b\00i\00t\00s\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $42 (i32.const 1836) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $43 (i32.const 1868) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00") + (data $44 (i32.const 1916) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!\00\00\00\00\00\00\00") + (data $45 (i32.const 2028) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $46 (i32.const 2092) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $47 (i32.const 2124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00o\00u\00t\00c\00o\00m\00e\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $48 (i32.const 2172) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00(\000\00x\00\00\00\00\00") + (data $49 (i32.const 2204) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") + (data $50 (i32.const 2236) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $51 (i32.const 2284) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006\00\00\00\00\00\00\00\00\00") + (data $52 (i32.const 2412) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") + (data $53 (i32.const 2476) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\000\00\00\00\00\00\00\00\00\00\00\00") + (data $54 (i32.const 2508) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\00") + (data $55 (i32.const 2908) "\1c\04\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $56 (i32.const 3964) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z\00\00\00\00\00") + (data $57 (i32.const 4060) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $58 (i32.const 4092) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $59 (i32.const 4140) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00G\00o\00t\00:\00 \00\'\00") + (data $60 (i32.const 4172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00\'\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 \00\'\00") + (data $61 (i32.const 4220) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00\'\00 \00@\00 \00\00\00\00\00") + (data $62 (i32.const 4252) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $63 (i32.const 4300) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $64 (i32.const 4348) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $65 (i32.const 4396) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $66 (i32.const 4444) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\18\00\00\00\00\00\00\00\00\00\00\00") + (data $67 (i32.const 4476) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00c\00o\00u\00n\00t\00_\00s\00e\00t\00_\00b\00i\00t\00s\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $68 (i32.const 4540) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\19\00\00\00\00\00\00\00\00\00\00\00") + (data $69 (i32.const 4572) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00l\00e\00a\00d\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\006\004\00\00\00\00\00") + (data $70 (i32.const 4636) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1a\00\00\00\00\00\00\00\00\00\00\00") + (data $71 (i32.const 4668) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00l\00e\00a\00d\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\003\002\00\00\00\00\00") + (data $72 (i32.const 4732) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1b\00\00\00\00\00\00\00\00\00\00\00") + (data $73 (i32.const 4764) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00t\00r\00a\00i\00l\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\006\004\00\00\00") + (data $74 (i32.const 4828) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1c\00\00\00\00\00\00\00\00\00\00\00") + (data $75 (i32.const 4860) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00t\00r\00a\00i\00l\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\003\002\00\00\00") + (data $76 (i32.const 4924) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1d\00\00\00\00\00\00\00\00\00\00\00") + (data $77 (i32.const 4956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00s\00i\00g\00n\00_\00e\00x\00t\00e\00n\00d\00_\008\00\00\00") + (data $78 (i32.const 5004) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1e\00\00\00\00\00\00\00\00\00\00\00") + (data $79 (i32.const 5036) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00s\00i\00g\00n\00_\00e\00x\00t\00e\00n\00d\00_\001\006\00") + (data $80 (i32.const 5084) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1f\00\00\00\00\00\00\00\00\00\00\00") + (data $81 (i32.const 5116) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00z\00e\00r\00o\00_\00e\00x\00t\00e\00n\00d\00_\001\006\00") + (data $82 (i32.const 5164) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $83 (i32.const 5196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00r\00e\00v\00e\00r\00s\00e\00_\00b\00y\00t\00e\00s\00\00\00") + (data $84 (i32.const 5244) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $85 (i32.const 5292) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $86 (i32.const 5340) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $87 (i32.const 5388) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00!\00\00\00\00\00\00\00\00\00\00\00") + (data $88 (i32.const 5420) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\"\00\00\00\00\00\00\00\00\00\00\00") + (data $89 (i32.const 5452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00#\00\00\00\00\00\00\00\00\00\00\00") + (data $90 (i32.const 5484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00$\00\00\00\00\00\00\00\00\00\00\00") + (data $91 (i32.const 5516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00%\00\00\00\00\00\00\00\00\00\00\00") + (data $92 (i32.const 5548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00&\00\00\00\00\00\00\00\00\00\00\00") + (data $93 (i32.const 5580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\'\00\00\00\00\00\00\00\00\00\00\00") + (data $94 (i32.const 5612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") + (data $95 (i32.const 5644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") + (data $96 (i32.const 5676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00*\00\00\00\00\00\00\00\00\00\00\00") + (data $97 (i32.const 5708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00+\00\00\00\00\00\00\00\00\00\00\00") + (data $98 (i32.const 5740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") + (data $99 (i32.const 5772) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00-\00\00\00\00\00\00\00\00\00\00\00") + (data $100 (i32.const 5804) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00.\00\00\00\00\00\00\00\00\00\00\00") + (data $101 (i32.const 5836) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00/\00\00\00\00\00\00\00\00\00\00\00") + (data $102 (i32.const 5868) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\000\00\00\00\00\00\00\00\00\00\00\00") + (data $103 (i32.const 5900) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\001\00\00\00\00\00\00\00\00\00\00\00") + (data $104 (i32.const 5932) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00b\00r\00a\00n\00c\00h\00_\00e\00q\00_\00i\00m\00m\00\00\00") + (data $105 (i32.const 5980) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00s\00t\00a\00t\00i\00c\00J\00u\00m\00p\00\00\00\00\00\00\00\00\00") + (data $106 (i32.const 6028) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $107 (i32.const 6076) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $108 (i32.const 6124) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $109 (i32.const 6172) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\002\00\00\00\00\00\00\00\00\00\00\00") + (data $110 (i32.const 6204) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\003\00\00\00\00\00\00\00\00\00\00\00") + (data $111 (i32.const 6236) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\004\00\00\00\00\00\00\00\00\00\00\00") + (data $112 (i32.const 6268) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\005\00\00\00\00\00\00\00\00\00\00\00") + (data $113 (i32.const 6300) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\006\00\00\00\00\00\00\00\00\00\00\00") + (data $114 (i32.const 6332) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\007\00\00\00\00\00\00\00\00\00\00\00") + (data $115 (i32.const 6364) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\008\00\00\00\00\00\00\00\00\00\00\00") + (data $116 (i32.const 6396) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\009\00\00\00\00\00\00\00\00\00\00\00") + (data $117 (i32.const 6428) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00:\00\00\00\00\00\00\00\00\00\00\00") + (data $118 (i32.const 6460) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00;\00\00\00\00\00\00\00\00\00\00\00") + (data $119 (i32.const 6492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00a\00n\00d\00_\00i\00n\00v\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $120 (i32.const 6540) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00<\00\00\00\00\00\00\00\00\00\00\00") + (data $121 (i32.const 6572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00o\00r\00_\00i\00n\00v\00") + (data $122 (i32.const 6604) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00=\00\00\00\00\00\00\00\00\00\00\00") + (data $123 (i32.const 6636) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00x\00n\00o\00r\00\00\00\00\00") + (data $124 (i32.const 6668) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00>\00\00\00\00\00\00\00\00\00\00\00") + (data $125 (i32.const 6700) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00?\00\00\00\00\00\00\00\00\00\00\00") + (data $126 (i32.const 6732) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00@\00\00\00\00\00\00\00\00\00\00\00") + (data $127 (i32.const 6764) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00A\00\00\00\00\00\00\00\00\00\00\00") + (data $128 (i32.const 6796) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00B\00\00\00\00\00\00\00\00\00\00\00") + (data $129 (i32.const 6828) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00C\00\00\00\00\00\00\00\00\00\00\00") + (data $130 (i32.const 6860) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00D\00\00\00\00\00\00\00\00\00\00\00") + (data $131 (i32.const 6892) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00E\00\00\00\00\00\00\00\00\00\00\00") + (data $132 (i32.const 6924) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00F\00\00\00\00\00\00\00\00\00\00\00") + (data $133 (i32.const 6956) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00G\00\00\00\00\00\00\00\00\00\00\00") + (data $134 (i32.const 6988) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00H\00\00\00\00\00\00\00\00\00\00\00") + (data $135 (i32.const 7020) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00I\00\00\00\00\00\00\00\00\00\00\00") + (data $136 (i32.const 7052) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00J\00\00\00\00\00\00\00\00\00\00\00") + (data $137 (i32.const 7084) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00K\00\00\00\00\00\00\00\00\00\00\00") + (data $138 (i32.const 7116) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00L\00\00\00\00\00\00\00\00\00\00\00") + (data $139 (i32.const 7148) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00M\00\00\00\00\00\00\00\00\00\00\00") + (data $140 (i32.const 7180) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00N\00\00\00\00\00\00\00\00\00\00\00") + (data $141 (i32.const 7212) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00O\00\00\00\00\00\00\00\00\00\00\00") + (data $142 (i32.const 7244) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00P\00\00\00\00\00\00\00\00\00\00\00") + (data $143 (i32.const 7276) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00Q\00\00\00\00\00\00\00\00\00\00\00") + (data $144 (i32.const 7308) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00R\00\00\00\00\00\00\00\00\00\00\00") + (data $145 (i32.const 7340) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00S\00\00\00\00\00\00\00\00\00\00\00") + (data $146 (i32.const 7372) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00T\00\00\00\00\00\00\00\00\00\00\00") + (data $147 (i32.const 7404) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00U\00\00\00\00\00\00\00\00\00\00\00") + (data $148 (i32.const 7436) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00V\00\00\00\00\00\00\00\00\00\00\00") + (data $149 (i32.const 7468) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00W\00\00\00\00\00\00\00\00\00\00\00") + (data $150 (i32.const 7500) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00X\00\00\00\00\00\00\00\00\00\00\00") + (data $151 (i32.const 7532) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00Y\00\00\00\00\00\00\00\00\00\00\00") + (data $152 (i32.const 7564) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00m\00a\00x\00\00\00\00\00\00\00") + (data $153 (i32.const 7596) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00Z\00\00\00\00\00\00\00\00\00\00\00") + (data $154 (i32.const 7628) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00m\00a\00x\00_\00u\00\00\00") + (data $155 (i32.const 7660) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00[\00\00\00\00\00\00\00\00\00\00\00") + (data $156 (i32.const 7692) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00m\00i\00n\00\00\00\00\00\00\00") + (data $157 (i32.const 7724) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\\\00\00\00\00\00\00\00\00\00\00\00") + (data $158 (i32.const 7756) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00m\00i\00n\00_\00u\00\00\00") + (data $159 (i32.const 7788) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") + (data $160 (i32.const 7820) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00a\00d\00d\00_\003\002\00") + (data $161 (i32.const 7852) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00^\00\00\00\00\00\00\00\00\00\00\00") + (data $162 (i32.const 7884) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00_\00\00\00\00\00\00\00\00\00\00\00") + (data $163 (i32.const 7916) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00`\00\00\00\00\00\00\00\00\00\00\00") + (data $164 (i32.const 7948) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") + (data $165 (i32.const 7980) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") + (data $166 (i32.const 8012) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") + (data $167 (i32.const 8044) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") + (data $168 (i32.const 8076) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00e\00\00\00\00\00\00\00\00\00\00\00") + (data $169 (i32.const 8108) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00f\00\00\00\00\00\00\00\00\00\00\00") + (data $170 (i32.const 8140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00r\00o\00t\00_\00r\00_\006\004\00_\00i\00m\00m\00\00\00\00\00") + (data $171 (i32.const 8188) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00g\00\00\00\00\00\00\00\00\00\00\00") + (data $172 (i32.const 8220) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00r\00o\00t\00_\00r\00_\006\004\00_\00i\00m\00m\00_\00a\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $173 (i32.const 8284) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00h\00\00\00\00\00\00\00\00\00\00\00") + (data $174 (i32.const 8316) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00r\00o\00t\00_\00l\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $175 (i32.const 8364) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00i\00\00\00\00\00\00\00\00\00\00\00") + (data $176 (i32.const 8396) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00r\00o\00t\00_\00l\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $177 (i32.const 8444) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00j\00\00\00\00\00\00\00\00\00\00\00") + (data $178 (i32.const 8476) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00h\00\00\00S\00h\00o\00w\00 \00f\00a\00i\00l\00 \00w\00h\00e\00n\00 \00a\00c\00c\00e\00s\00s\00i\00n\00g\00 \00a\00n\00y\00 \00o\00f\00 \00t\00h\00e\00 \00i\00n\00i\00t\00i\00a\00l\00 \001\006\00 \00p\00a\00g\00e\00s\00\00\00\00\00") + (data $179 (i32.const 8604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t\00\00\00\00\00\00\00\00\00") + (data $180 (i32.const 8668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s\00\00\00\00\00\00\00") + (data $181 (i32.const 8716) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $182 (i32.const 8844) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $183 (i32.const 8924) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00a\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $184 (i32.const 8972) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $185 (i32.const 9020) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00t\00r\00u\00e\00\00\00\00\00") + (data $186 (i32.const 9052) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00f\00a\00l\00s\00e\00\00\00") + (data $187 (i32.const 9084) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $188 (i32.const 9132) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $189 (i32.const 9180) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00a\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $190 (i32.const 9228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00b\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $191 (i32.const 9276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00b\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $192 (i32.const 9324) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00k\00\00\00\00\00\00\00\00\00\00\00") + (data $193 (i32.const 9356) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00S\00h\00o\00w\00 \00f\00a\00i\00l\00 \00o\00n\00 \00m\00i\00s\00s\00i\00n\00g\00 \00p\00a\00g\00e\00 \00o\00r\00 \00i\00n\00v\00a\00l\00i\00d\00 \00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00") + (data $194 (i32.const 9468) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 \00") + (data $195 (i32.const 9564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y\00") + (data $196 (i32.const 9612) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.\00") + (data $197 (i32.const 9708) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00c\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $198 (i32.const 9756) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00c\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $199 (i32.const 9804) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00l\00\00\00\00\00\00\00\00\00\00\00") + (data $200 (i32.const 9836) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00s\00h\00o\00u\00l\00d\00 \00r\00e\00a\00d\00 \00a\00n\00d\00 \00w\00r\00i\00t\00e\00 \00a\00c\00r\00o\00s\00s\00 \00p\00a\00g\00e\00s\00\00\00\00\00\00\00\00\00") + (data $201 (i32.const 9932) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\10\00\00\00\de\00\00\00\ad\00\00\00\be\00\00\00\ef\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $202 (i32.const 9980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") + (data $203 (i32.const 10012) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00J\00\00\001\007\003\00,\001\009\000\00,\002\003\009\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00\00\00") + (data $204 (i32.const 10108) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $205 (i32.const 10156) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00N\00\00\002\002\002\00,\001\007\003\00,\001\009\000\00,\002\003\009\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $206 (i32.const 10268) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00m\00\00\00\00\00\00\00\00\00\00\00") + (data $207 (i32.const 10300) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00`\00\00\00s\00h\00o\00u\00l\00d\00 \00a\00l\00l\00o\00w\00 \000\00-\00b\00y\00t\00e\00s\00 \00r\00e\00a\00d\00s\00 \00a\00n\00d\00 \00w\00r\00i\00t\00e\00s\00 \00e\00v\00e\00r\00y\00w\00h\00e\00r\00e\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $208 (i32.const 10428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00d\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $209 (i32.const 10476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00e\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $210 (i32.const 10524) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00n\00\00\00\00\00\00\00\00\00\00\00") + (data $211 (i32.const 10556) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00o\00\00\00\00\00\00\00\00\00\00\00") + (data $212 (i32.const 10588) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00p\00\00\00\00\00\00\00\00\00\00\00") + (data $213 (i32.const 10620) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00q\00\00\00\00\00\00\00\00\00\00\00") + (data $214 (i32.const 10652) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00r\00\00\00\00\00\00\00\00\00\00\00") + (data $215 (i32.const 10684) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $216 (i32.const 10716) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00t\00\00\00\00\00\00\00\00\00\00\00") + (data $217 (i32.const 10748) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00u\00\00\00\00\00\00\00\00\00\00\00") + (data $218 (i32.const 10780) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00v\00\00\00\00\00\00\00\00\00\00\00") + (data $219 (i32.const 10812) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00w\00\00\00\00\00\00\00\00\00\00\00") + (data $220 (i32.const 10844) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00x\00\00\00\00\00\00\00\00\00\00\00") + (data $221 (i32.const 10876) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00y\00\00\00\00\00\00\00\00\00\00\00") + (data $222 (i32.const 10908) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00z\00\00\00\00\00\00\00\00\00\00\00") + (data $223 (i32.const 10940) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00{\00\00\00\00\00\00\00\00\00\00\00") + (data $224 (i32.const 10972) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00|\00\00\00\00\00\00\00\00\00\00\00") + (data $225 (i32.const 11004) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00}\00\00\00\00\00\00\00\00\00\00\00") + (data $226 (i32.const 11036) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00~\00\00\00\00\00\00\00\00\00\00\00") + (data $227 (i32.const 11068) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\7f\00\00\00\00\00\00\00\00\00\00\00") + (data $228 (i32.const 11100) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\80\00\00\00\00\00\00\00\00\00\00\00") + (data $229 (i32.const 11132) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\81\00\00\00\00\00\00\00\00\00\00\00") + (data $230 (i32.const 11164) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\82\00\00\00\00\00\00\00\00\00\00\00") + (data $231 (i32.const 11196) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\83\00\00\00\00\00\00\00\00\00\00\00") + (data $232 (i32.const 11228) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\84\00\00\00\00\00\00\00\00\00\00\00") + (data $233 (i32.const 11260) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\85\00\00\00\00\00\00\00\00\00\00\00") + (data $234 (i32.const 11292) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\86\00\00\00\00\00\00\00\00\00\00\00") + (data $235 (i32.const 11324) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\87\00\00\00\00\00\00\00\00\00\00\00") + (data $236 (i32.const 11356) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\88\00\00\00\00\00\00\00\00\00\00\00") + (data $237 (i32.const 11388) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\89\00\00\00\00\00\00\00\00\00\00\00") + (data $238 (i32.const 11420) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8a\00\00\00\00\00\00\00\00\00\00\00") + (data $239 (i32.const 11452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8b\00\00\00\00\00\00\00\00\00\00\00") + (data $240 (i32.const 11484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8c\00\00\00\00\00\00\00\00\00\00\00") + (data $241 (i32.const 11516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8d\00\00\00\00\00\00\00\00\00\00\00") + (data $242 (i32.const 11548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8e\00\00\00\00\00\00\00\00\00\00\00") + (data $243 (i32.const 11580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8f\00\00\00\00\00\00\00\00\00\00\00") + (data $244 (i32.const 11612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\90\00\00\00\00\00\00\00\00\00\00\00") + (data $245 (i32.const 11644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\91\00\00\00\00\00\00\00\00\00\00\00") + (data $246 (i32.const 11676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\92\00\00\00\00\00\00\00\00\00\00\00") + (data $247 (i32.const 11708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\93\00\00\00\00\00\00\00\00\00\00\00") + (data $248 (i32.const 11740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\94\00\00\00\00\00\00\00\00\00\00\00") + (data $249 (i32.const 11772) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\95\00\00\00\00\00\00\00\00\00\00\00") + (data $250 (i32.const 11804) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\96\00\00\00\00\00\00\00\00\00\00\00") + (data $251 (i32.const 11836) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\97\00\00\00\00\00\00\00\00\00\00\00") + (data $252 (i32.const 11868) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\98\00\00\00\00\00\00\00\00\00\00\00") + (data $253 (i32.const 11900) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\99\00\00\00\00\00\00\00\00\00\00\00") + (data $254 (i32.const 11932) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9a\00\00\00\00\00\00\00\00\00\00\00") + (data $255 (i32.const 11964) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9b\00\00\00\00\00\00\00\00\00\00\00") + (data $256 (i32.const 11996) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") + (data $257 (i32.const 12028) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") + (data $258 (i32.const 12060) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9e\00\00\00\00\00\00\00\00\00\00\00") + (data $259 (i32.const 12092) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9f\00\00\00\00\00\00\00\00\00\00\00") + (data $260 (i32.const 12124) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a0\00\00\00\00\00\00\00\00\00\00\00") + (data $261 (i32.const 12156) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a1\00\00\00\00\00\00\00\00\00\00\00") + (data $262 (i32.const 12188) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a2\00\00\00\00\00\00\00\00\00\00\00") + (data $263 (i32.const 12220) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a3\00\00\00\00\00\00\00\00\00\00\00") + (data $264 (i32.const 12252) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a4\00\00\00\00\00\00\00\00\00\00\00") + (data $265 (i32.const 12284) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a5\00\00\00\00\00\00\00\00\00\00\00") + (data $266 (i32.const 12316) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a6\00\00\00\00\00\00\00\00\00\00\00") + (data $267 (i32.const 12348) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a7\00\00\00\00\00\00\00\00\00\00\00") + (data $268 (i32.const 12380) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a8\00\00\00\00\00\00\00\00\00\00\00") + (data $269 (i32.const 12412) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a9\00\00\00\00\00\00\00\00\00\00\00") + (data $270 (i32.const 12444) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\aa\00\00\00\00\00\00\00\00\00\00\00") + (data $271 (i32.const 12476) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ab\00\00\00\00\00\00\00\00\00\00\00") + (data $272 (i32.const 12508) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ac\00\00\00\00\00\00\00\00\00\00\00") + (data $273 (i32.const 12540) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ad\00\00\00\00\00\00\00\00\00\00\00") + (data $274 (i32.const 12572) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ae\00\00\00\00\00\00\00\00\00\00\00") + (data $275 (i32.const 12604) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\af\00\00\00\00\00\00\00\00\00\00\00") + (data $276 (i32.const 12636) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b0\00\00\00\00\00\00\00\00\00\00\00") + (data $277 (i32.const 12668) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b1\00\00\00\00\00\00\00\00\00\00\00") + (data $278 (i32.const 12700) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b2\00\00\00\00\00\00\00\00\00\00\00") + (data $279 (i32.const 12732) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b3\00\00\00\00\00\00\00\00\00\00\00") + (data $280 (i32.const 12764) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b4\00\00\00\00\00\00\00\00\00\00\00") + (data $281 (i32.const 12796) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00\901\00\00\b01\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d01\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d0)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p/\00\00\90/\00\00\b0/\00\00\d0/\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00P)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p)\00\00\f0)\00\00\10*\00\000*\00\00P*\00\00p*\00\00\90*\00\00\b0*\00\00\d0*\00\00\f0/\00\00\100\00\0000\00\00P0\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p0\00\00\900\00\00\b00\00\00\d00\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\90)\00\00@\15\00\00`\15\00\00\80\15\00\00\a0\15\00\00\c0\15\00\00\e0\15\00\00\00\16\00\00 \16\00\00@\16\00\00`\16\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d0+\00\00\f01\00\00\c0\05\00\00\e0\05\00\00\00\06\00\00 \06\00\00@\06\00\00`\06\00\00\80\06\00\00\a0\06\00\00\c0\06\00\00\e0\06\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\f00\00\00\101\00\0001\00\00P1\00\00\f0*\00\00\10+\00\000+\00\00P+\00\00p+\00\00\90+\00\00\b0+\00\00@\1a\00\00P\18\00\00p\18\00\00\90\18\00\00`\1a\00\00p,\00\00\90,\00\000-\00\00P-\00\00p-\00\00\80\1a\00\00\b0,\00\00\d0,\00\00\90-\00\00\b0-\00\00\d0-\00\00\f0+\00\00\10,\00\00\a0\1a\00\00\c0\1a\00\00\f0-\00\00\10.\00\000.\00\00\e0\1a\00\00P.\00\00p.\00\00\90.\00\00\e0\1e\00\00\00\1f\00\00 \1f\00\00@\1f\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\80\16\00\00\a0\16\00\00\c0\16\00\00\e0\16\00\00\00\17\00\00 \17\00\00p1\00\00p1\00\00p1\00\00p1\00\00\b0)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\00\1b\00\00 \1b\00\00@\1b\00\00`\1b\00\00\80\1b\00\00\a0\1b\00\00\c0\1b\00\00\b0.\00\00\d0.\00\00\f0.\00\00\e0\1b\00\00\00\1c\00\00 \1c\00\00@\1c\00\00`\1c\00\00\80\1c\00\00\a0\1c\00\00\10/\00\000/\00\00P/\00\00\b0\18\00\00\d0\18\00\00\f0\18\00\00\c0\1c\00\00\e0\1c\00\00\00\1d\00\00\f0,\00\00\10-\00\000,\00\00P,\00\00`\1f\00\00\80\1f\00\00\a0\1f\00\00\c0\1f\00\00\10\19\00\000\19\00\00P\19\00\00 \1d\00\00@\1d\00\00`\1d\00\00\80\1d\00\00") + (data $282 (i32.const 13740) ",\00\00\00\00\00\00\00\00\00\00\00!\00\00\00\10\00\00\00\102\00\00\102\00\00\9c\03\00\00\e7\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $283 (i32.const 13788) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80\00\00\00\00") + (data $284 (i32.const 13820) ",\00\00\00\00\00\00\00\00\00\00\00\"\00\00\00\10\00\00\00\f05\00\00\f05\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $285 (i32.const 13868) "\1c\00\00\00\00\00\00\00\00\00\00\00#\00\00\00\08\00\00\00\b5\00\00\00\00\00\00\00\00\00\00\00") + (data $286 (i32.const 13900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $287 (i32.const 13948) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00S\00B\00R\00K\00\00\00\00\00") + (data $288 (i32.const 13980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00T\00R\00A\00P\00\00\00\00\00") + (data $289 (i32.const 14012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H\00\00\00\00\00\00\00") + (data $290 (i32.const 14060) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I\00") + (data $291 (i32.const 14092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00") + (data $292 (i32.const 14140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008\00\00\00\00\00") + (data $293 (i32.const 14188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006\00\00\00") + (data $294 (i32.const 14236) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002\00\00\00") + (data $295 (i32.const 14284) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004\00\00\00") + (data $296 (i32.const 14332) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00J\00U\00M\00P\00\00\00\00\00") + (data $297 (i32.const 14364) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $298 (i32.const 14412) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $299 (i32.const 14460) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $300 (i32.const 14508) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $301 (i32.const 14556) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $302 (i32.const 14604) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $303 (i32.const 14652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $304 (i32.const 14700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $305 (i32.const 14748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $306 (i32.const 14796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $307 (i32.const 14844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") + (data $308 (i32.const 14892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $309 (i32.const 14940) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $310 (i32.const 14988) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $311 (i32.const 15052) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") + (data $312 (i32.const 15116) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $313 (i32.const 15180) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $314 (i32.const 15244) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00\00\00") + (data $315 (i32.const 15292) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M\00\00\00") + (data $316 (i32.const 15340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M\00\00\00") + (data $317 (i32.const 15388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $318 (i32.const 15452) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $319 (i32.const 15516) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $320 (i32.const 15580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $321 (i32.const 15644) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $322 (i32.const 15708) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $323 (i32.const 15772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $324 (i32.const 15836) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $325 (i32.const 15900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $326 (i32.const 15948) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $327 (i32.const 16012) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $328 (i32.const 16076) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00") + (data $329 (i32.const 16140) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00") + (data $330 (i32.const 16204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00") + (data $331 (i32.const 16268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00") + (data $332 (i32.const 16332) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008\00\00\00") + (data $333 (i32.const 16380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") + (data $334 (i32.const 16428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") + (data $335 (i32.const 16476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S\00\00\00") + (data $336 (i32.const 16524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00") + (data $337 (i32.const 16572) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006\00\00\00") + (data $338 (i32.const 16620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002\00\00\00") + (data $339 (i32.const 16668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004\00\00\00") + (data $340 (i32.const 16716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00") + (data $341 (i32.const 16764) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008\00\00\00\00\00\00\00") + (data $342 (i32.const 16812) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00") + (data $343 (i32.const 16860) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006\00\00\00\00\00") + (data $344 (i32.const 16908) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00") + (data $345 (i32.const 16956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002\00\00\00\00\00") + (data $346 (i32.const 17004) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00") + (data $347 (i32.const 17052) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") + (data $348 (i32.const 17100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $349 (i32.const 17148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $350 (i32.const 17196) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M\00") + (data $351 (i32.const 17228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") + (data $352 (i32.const 17276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") + (data $353 (i32.const 17324) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") + (data $354 (i32.const 17372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $355 (i32.const 17420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $356 (i32.const 17468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $357 (i32.const 17516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00") + (data $358 (i32.const 17564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") + (data $359 (i32.const 17612) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") + (data $360 (i32.const 17660) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $361 (i32.const 17724) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $362 (i32.const 17788) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $363 (i32.const 17852) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") + (data $364 (i32.const 17900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") + (data $365 (i32.const 17948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") + (data $366 (i32.const 17996) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") + (data $367 (i32.const 18044) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $368 (i32.const 18092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $369 (i32.const 18140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $370 (i32.const 18188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00") + (data $371 (i32.const 18236) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $372 (i32.const 18300) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $373 (i32.const 18364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $374 (i32.const 18428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00\00\00\00\00") + (data $375 (i32.const 18476) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $376 (i32.const 18540) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00\00\00\00\00") + (data $377 (i32.const 18588) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $378 (i32.const 18652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00\00\00\00\00\00\00\00\00\00\00") + (data $379 (i32.const 18700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00\00\00\00\00\00\00\00\00\00\00") + (data $380 (i32.const 18748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00\00\00\00\00\00\00") + (data $381 (i32.const 18796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00\00\00\00\00\00\00") + (data $382 (i32.const 18844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00\00\00\00\00\00\00") + (data $383 (i32.const 18892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00\00\00\00\00\00\00") + (data $384 (i32.const 18940) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00") + (data $385 (i32.const 19004) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002\00") + (data $386 (i32.const 19036) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002\00") + (data $387 (i32.const 19068) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002\00") + (data $388 (i32.const 19100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $389 (i32.const 19148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $390 (i32.const 19196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $391 (i32.const 19244) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $392 (i32.const 19292) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $393 (i32.const 19340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $394 (i32.const 19388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $395 (i32.const 19436) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004\00") + (data $396 (i32.const 19468) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004\00") + (data $397 (i32.const 19500) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004\00") + (data $398 (i32.const 19532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $399 (i32.const 19580) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $400 (i32.const 19628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $401 (i32.const 19676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $402 (i32.const 19724) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $403 (i32.const 19772) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $404 (i32.const 19820) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $405 (i32.const 19868) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00A\00N\00D\00\00\00\00\00\00\00") + (data $406 (i32.const 19900) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00X\00O\00R\00\00\00\00\00\00\00") + (data $407 (i32.const 19932) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00O\00R\00\00\00\00\00\00\00\00\00") + (data $408 (i32.const 19964) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S\00\00\00") + (data $409 (i32.const 20012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U\00\00\00") + (data $410 (i32.const 20060) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U\00\00\00") + (data $411 (i32.const 20108) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $412 (i32.const 20156) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $413 (i32.const 20204) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $414 (i32.const 20252) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $415 (i32.const 20300) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $416 (i32.const 20348) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $417 (i32.const 20396) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $418 (i32.const 20444) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $419 (i32.const 20492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $420 (i32.const 20540) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V\00") + (data $421 (i32.const 20572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00X\00N\00O\00R\00\00\00\00\00") + (data $422 (i32.const 20604) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00A\00X\00\00\00\00\00\00\00") + (data $423 (i32.const 20636) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00A\00X\00_\00U\00\00\00") + (data $424 (i32.const 20668) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00I\00N\00\00\00\00\00\00\00") + (data $425 (i32.const 20700) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00I\00N\00_\00U\00\00\00") + (data $426 (i32.const 20732) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00s\00h\00o\00u\00l\00d\00 \00p\00a\00r\00s\00e\00 \00p\00a\00c\00k\00e\00d\00 \00m\00a\00s\00k\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00\00\00\00\00\00\00\00\00") + (data $427 (i32.const 20828) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\18\00\00\00\00\00\00\00\00\000@\00\00\00\00\00\00`@\00\00\00\00\00\00o@\00\00\00\00") + (data $428 (i32.const 20876) "l\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00T\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\n\00\00\00\t\00\00\00\08\00\00\00\07\00\00\00\06\00\00\00\05\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $429 (i32.const 20988) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00l\00e\00n\00g\00t\00h\00 \00@\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $430 (i32.const 21036) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b6\00\00\00\00\00\00\00\00\00\00\00") + (data $431 (i32.const 21068) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00X\00\00\00s\00h\00o\00u\00l\00d\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00 \00s\00k\00i\00p\00p\00i\00n\00g\00 \00m\00o\00r\00e\00 \00t\00h\00a\00n\00 \002\004\00 \00b\00y\00t\00e\00s\00\00\00\00\00") + (data $432 (i32.const 21180) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00`@\00\00\00\00\00\00\00\00\00\00\00\00") + (data $433 (i32.const 21244) "\9c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\80\00\00\00\00\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\18\00\00\00\17\00\00\00\16\00\00\00\15\00\00\00\14\00\00\00\13\00\00\00\12\00\00\00\11\00\00\00\10\00\00\00\0f\00\00\00\0e\00\00\00\r\00\00\00\0c\00\00\00\0b\00\00\00\n\00\00\00\t\00\00\00\08\00\00\00\07\00\00\00\06\00\00\00\05\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $434 (i32.const 21404) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b7\00\00\00\00\00\00\00\00\00\00\00") + (data $435 (i32.const 21436) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00B\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00\00\00\00\00\00\00\00\00\00\00") + (data $436 (i32.const 21532) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\00\00\00\00\00\00\00") + (data $437 (i32.const 21596) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $438 (i32.const 21724) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") + (data $439 (i32.const 21756) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") + (data $440 (i32.const 21788) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") + (data $441 (i32.const 21820) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") + (data $442 (i32.const 21852) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b8\00\00\00\00\00\00\00\00\00\00\00") + (data $443 (i32.const 21884) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00p\00o\00s\00i\00t\00i\00v\00e\00 \00b\00o\00u\00n\00d\00e\00d\00 \00b\00y\00 \00s\00k\00i\00p\00") + (data $444 (i32.const 21980) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\10\00\00\00\00\00\00\00\00\00\14@\00\00\00\00\00\00\14@\00\00\00\00\00\00\00\00\00\00\00\00") + (data $445 (i32.const 22028) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b9\00\00\00\00\00\00\00\00\00\00\00") + (data $446 (i32.const 22060) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00b\00l\00o\00b\00 \00p\00r\00o\00g\00r\00a\00m\00\00\00") + (data $447 (i32.const 22124) "\\\01\00\00\00\00\00\00\00\00\00\00\01\00\00\00H\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\80@@\00\00\00\00\00\80I@\00\00\00\00\00\00 @\00\00\00\00\00\00\f0?\00\00\00\00\00\80I@\00\00\00\00\00\00\"@\00\00\00\00\00\00\f0?\00\00\00\00\00\00D@\00\00\00\00\00\00\08@\00\00\00\00\00\00\00\00\00\00\00\00\00\a0b@\00\00\00\00\00\c0]@\00\00\00\00\00\e0o@\00\00\00\00\00@T@\00\00\00\00\00\00\1c@\00\00\00\00\00\00(@\00\00\00\00\00\00Y@\00\00\00\00\00@a@\00\00\00\00\00\00i@\00\00\00\00\00\00c@\00\00\00\00\00\00 @\00\00\00\00\00\00Y@\00\00\00\00\00 e@\00\00\00\00\00\00D@\00\00\00\00\00`n@\00\00\00\00\00\00Y@\00\00\00\00\00\e0`@\00\00\00\00\00\80I@\00\00\00\00\00\00 @\00\00\00\00\00\80I@\00\00\00\00\00\00\"@\00\00\00\00\00\00\f0?\00\00\00\00\00\00I@\00\00\00\00\00\00\00\00\00\00\00\00\00@R@\00\00\00\00\00`b@\00\00\00\00\00\80T@\00\00\00\00\00\a0j@\00\00\00\00\00\00\00\00\00\00\00\00") + (data $448 (i32.const 22476) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 \00\00\00") + (data $449 (i32.const 22556) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $450 (i32.const 22604) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\e0W\00\00\00\00\00\000X\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $451 (i32.const 22652) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $452 (i32.const 22716) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 \00\00\00\00\00\00\00\00\00") + (data $453 (i32.const 22828) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $454 (i32.const 22876) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\d0X\00\00\00\00\00\00@Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $455 (i32.const 22924) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00a\00s\00k\00[\00\00\00") + (data $456 (i32.const 22956) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00,\00 \00\00\00\00\00\00\00\00\00") + (data $457 (i32.const 22988) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") + (data $458 (i32.const 23020) "\ec\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\d2\00\00\00M\00a\00s\00k\00[\000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \000\00,\00 \001\00,\00 \00]\00\00\00\00\00\00\00\00\00\00\00") + (data $459 (i32.const 23260) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00\00\00\00\00\00\00\00\00") + (data $460 (i32.const 23308) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00-\00>\00 \00\00\00\00\00") + (data $461 (i32.const 23340) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00 [\00\00\00\00\00\00\c0Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $462 (i32.const 23388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00]\00\00\00\00\00\00\00") + (data $463 (i32.const 23436) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\00\00\00\00\00") + (data $464 (i32.const 23484) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00s\00t\00a\00r\00t\00\00\00") + (data $465 (i32.const 23516) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00e\00n\00d\00\00\00\00\00\00\00") + (data $466 (i32.const 23548) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00 [\00\00\00\00\00\00\c0Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $467 (i32.const 23596) ",\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\01\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \006\00 \00-\00>\00 \00e\00n\00d\00,\00 \008\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \009\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \001\002\00 \00-\00>\00 \00e\00n\00d\00,\00 \001\005\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \002\002\00 \00-\00>\00 \00e\00n\00d\00,\00 \002\004\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \003\000\00 \00-\00>\00 \00e\00n\00d\00,\00 \003\001\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \00]\00\00\00\00\00\00\00\00\00\00\00") + (data $468 (i32.const 23900) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\ba\00\00\00\00\00\00\00\00\00\00\00") + (data $469 (i32.const 23932) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00j\00\00\00s\00h\00o\00u\00l\00d\00 \00c\00o\00n\00s\00t\00r\00u\00c\00t\00 \00b\00a\00s\00i\00c\00 \00b\00l\00o\00c\00k\00s\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00 \00b\00a\00s\00e\00d\00 \00o\00n\00 \00s\00k\00i\00p\00\00\00") + (data $470 (i32.const 24060) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00Z\00\00\00O\00p\00c\00o\00d\00e\00 \00n\00o\00t\00 \00f\00o\00u\00n\00d\00 \00i\00n\00 \00R\00U\00N\00 \00t\00a\00b\00l\00e\00 \00f\00o\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00\00\00") + (data $471 (i32.const 24172) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00e\00s\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $472 (i32.const 24252) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00`@\00\00\00\00\00\00\00\00\00\00\00\00") + (data $473 (i32.const 24316) "\0c\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\f6\00\00\00M\00a\00s\00k\00[\000\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\004\00,\00 \002\003\00,\00 \002\002\00,\00 \002\001\00,\00 \002\000\00,\00 \001\009\00,\00 \001\008\00,\00 \001\007\00,\00 \001\006\00,\00 \001\005\00,\00 \001\004\00,\00 \001\003\00,\00 \001\002\00,\00 \001\001\00,\00 \001\000\00,\00 \009\00,\00 \008\00,\00 \007\00,\00 \006\00,\00 \005\00,\00 \004\00,\00 \003\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \00]\00\00\00\00\00\00\00") + (data $474 (i32.const 24588) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00h\00\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \002\006\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \003\001\00 \00-\00>\00 \00e\00n\00d\00,\00 \00]\00\00\00\00\00") + (data $475 (i32.const 24716) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bb\00\00\00\00\00\00\00\00\00\00\00") + (data $476 (i32.const 24748) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00s\00h\00o\00u\00l\00d\00 \00p\00a\00r\00s\00e\00 \00j\00u\00m\00p\00 \00t\00a\00b\00l\00e\00 \00w\00i\00t\00h\00 \00l\00a\00r\00g\00e\00 \00n\00u\00m\00b\00e\00r\00s\00\00\00\00\00\00\00\00\00") + (data $477 (i32.const 24860) "\0c\01\00\00\00\00\00\00\00\00\00\00\01\00\00\00\f0\00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $478 (i32.const 25132) "\cc\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\b8\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\000\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \001\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \002\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \00]\00\00\00\00\00") + (data $479 (i32.const 25340) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bc\00\00\00\00\00\00\00\00\00\00\00") + (data $480 (i32.const 25372) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00<\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00s\00t\00a\00n\00d\00a\00r\00d\00 \00p\00r\00o\00g\00r\00a\00m\00") + (data $481 (i32.const 25452) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\1c\00\00\00\04\00\00\02\00\00\03\00 \00\00\ab\cd\ef\01\124\07\00\00\00\00\00\03\c8\87\t\01") + (data $482 (i32.const 25500) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\03\00\00\00\124V\00\00\00\00\00\00\00\00\00") + (data $483 (i32.const 25532) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00A\00r\00g\00u\00m\00e\00n\00t\00s\00 \00l\00e\00n\00g\00t\00h\00 \00t\00o\00o\00 \00b\00i\00g\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $484 (i32.const 25612) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00s\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $485 (i32.const 25676) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") + (data $486 (i32.const 25804) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00\00\00\00\00\00\00") + (data $487 (i32.const 25884) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $488 (i32.const 25948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \00\00\00") + (data $489 (i32.const 25996) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00}\00\00\00\00\00\00\00\00\00") + (data $490 (i32.const 26028) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00\e0d\00\00\00\00\00\000e\00\00\00\00\00\00pe\00\00\00\00\00\00\a0e\00\00") + (data $491 (i32.const 26076) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $492 (i32.const 26140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00m\00a\00s\00k\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $493 (i32.const 26188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00\00\00") + (data $494 (i32.const 26236) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $495 (i32.const 26300) "<\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00$\00\00\00\f0e\00\00\00\00\00\000f\00\00\00\00\00\00`f\00\00\00\00\00\00\90f\00\00\00\00\00\00\a0e\00\00\00\00\00\00\00\00\00\00") + (data $496 (i32.const 26364) "\dc\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\c2\01\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \002\000\000\00,\001\003\005\00,\009\00,\00 \00m\00a\00s\00k\00:\00 \00M\00a\00s\00k\00[\000\00,\00 \002\00,\00 \001\00,\00 \00]\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00]\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \00]\00 \00}\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \007\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \004\002\009\004\009\000\001\007\006\000\00,\004\002\007\008\000\005\009\000\000\008\00,\000\00,\000\00,\000\00,\000\00,\000\00,\004\002\007\008\001\002\004\005\004\004\00,\003\00,\000\00,\000\00,\000\00,\000\00 \00}\00\00\00\00\00\00\00\00\00\00\00") + (data $497 (i32.const 26844) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bd\00\00\00\00\00\00\00\00\00\00\00") + (data $498 (i32.const 26876) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00b\00i\00t\00.\00t\00s\00") + (data $499 (i32.const 26908) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00>\00 \00\00\00\00\00\00\00\00\00") + (data $500 (i32.const 26940) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00>\00>\00>\00 \00") + (data $501 (i32.const 26972) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00<\00<\00<\00 \00") + (data $502 (i32.const 27004) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00\05\'\00\00\00\00\00\00\00\00") + (data $503 (i32.const 27036) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00pi\00\00\00\00\00\00\90i\00\00") + (data $504 (i32.const 27068) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00 \00 \00 \00\00\00\00\00") + (data $505 (i32.const 27100) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00=\d84\dd\00\00\00\00\00\00") + (data $506 (i32.const 27132) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00pi\00\00\00\00\00\00\f0i\00\00") + (data $507 (i32.const 27164) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00<\00 \00\00\00\00\00\00\00\00\00") + (data $508 (i32.const 27196) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\05\'\00\00\00\00\00\00\00\00\00\00") + (data $509 (i32.const 27228) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00=\d84\dd\00\00\00\00\00\00\00\00") + (data $510 (i32.const 27260) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $511 (i32.const 27292) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00/\00 \00\00\00\00\00\00\00") + (data $512 (i32.const 27324) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00\00\00\00\00\90j\00\00\00\00\00\00\b0j\00\00\00\00\00\00\90j\00\00\00\00\00\00") + (data $513 (i32.const 27372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00b\00r\00a\00n\00c\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $514 (i32.const 27420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00l\00o\00g\00i\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $515 (i32.const 27468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00m\00a\00t\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $516 (i32.const 27516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $517 (i32.const 27564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $518 (i32.const 27612) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00r\00o\00t\00.\00t\00s\00") + (data $519 (i32.const 27644) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00s\00p\00i\00.\00t\00s\00") + (data $520 (i32.const 27676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00\n\00\n\00T\00o\00t\00a\00l\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $521 (i32.const 27724) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00S\00o\00m\00e\00 \00t\00e\00s\00t\00s\00 \00f\00a\00i\00l\00e\00d\00.\00\00\00\00\00\00\00\00\00") + (data $522 (i32.const 27788) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00t\00e\00s\00t\00-\00r\00u\00n\00.\00t\00s\00\00\00\00\00") + (data $523 (i32.const 27856) "0\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\02A\00\00\02A\00\00\00\00\00\00\04A\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00A\00\00\00\02A\00\00B\00\00\00\00\00\00\00\02\01\00\00\00\00\00\00$\01\00\00\02\1a\00\00\02\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\t\00\00\00\00\00\00 \00\00\00\00\00\00\00") + (table $0 190 190 funcref) + (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/bit.test~anonymous|0 $start:assembly/instructions/bit.test~anonymous|1 $start:assembly/instructions/bit.test~anonymous|2 $start:assembly/instructions/bit.test~anonymous|3 $start:assembly/instructions/bit.test~anonymous|4 $start:assembly/instructions/bit.test~anonymous|5 $start:assembly/instructions/bit.test~anonymous|6 $start:assembly/instructions/bit.test~anonymous|7 $start:assembly/instructions/bit.test~anonymous|8 $start:assembly/instructions/bit.test~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/branch.test~anonymous|0 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/logic.test~anonymous|0 $start:assembly/instructions/logic.test~anonymous|1 $start:assembly/instructions/logic.test~anonymous|2 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/math.test~anonymous|0 $start:assembly/instructions/math.test~anonymous|1 $start:assembly/instructions/math.test~anonymous|2 $start:assembly/instructions/math.test~anonymous|3 $start:assembly/instructions/math.test~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/rot.test~anonymous|0 $start:assembly/instructions/rot.test~anonymous|1 $start:assembly/instructions/rot.test~anonymous|2 $start:assembly/instructions/rot.test~anonymous|3 $start:assembly/memory.test~anonymous|0 $start:assembly/memory.test~anonymous|1 $start:assembly/memory.test~anonymous|2 $start:assembly/memory.test~anonymous|3 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $start:assembly/program.test~anonymous|0 $start:assembly/program.test~anonymous|1 $start:assembly/program.test~anonymous|2 $start:assembly/program.test~anonymous|3 $start:assembly/program.test~anonymous|4 $start:assembly/program.test~anonymous|5 $start:assembly/program.test~anonymous|6 $start:assembly/spi.test~anonymous|0) + (export "runAllTests" (func $assembly/test-run/runAllTests)) + (export "memory" (memory $0)) + (start $~start) + (func $~lib/rt/itcms/Object#set:nextWithColor (param $this i32) (param $nextWithColor i32) + local.get $this + local.get $nextWithColor + i32.store offset=4 + ) + (func $~lib/rt/itcms/Object#set:prev (param $this i32) (param $prev i32) + local.get $this + local.get $prev + i32.store offset=8 + ) + (func $~lib/rt/itcms/initLazy (param $space i32) (result i32) + local.get $space + local.get $space + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $space + local.get $space + call $~lib/rt/itcms/Object#set:prev + local.get $space + return + ) + (func $~lib/rt/itcms/Object#get:nextWithColor (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/rt/itcms/Object#get:next (param $this i32) (result i32) + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.const -1 + i32.xor + i32.and + return + ) + (func $~lib/rt/itcms/Object#get:color (param $this i32) (result i32) + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.and + return + ) + (func $~lib/rt/itcms/visitRoots (param $cookie i32) + (local $pn i32) + (local $iter i32) + local.get $cookie + call $~lib/rt/__visit_globals + global.get $~lib/rt/itcms/pinSpace + local.set $pn + local.get $pn + call $~lib/rt/itcms/Object#get:next + local.set $iter + loop $while-continue|0 + local.get $iter + local.get $pn + i32.ne + if + i32.const 1 + drop + local.get $iter + call $~lib/rt/itcms/Object#get:color + i32.const 3 + i32.eq + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 160 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $iter + i32.const 20 + i32.add + local.get $cookie + call $~lib/rt/__visit_members + local.get $iter + call $~lib/rt/itcms/Object#get:next + local.set $iter + br $while-continue|0 + end + end + ) + (func $~lib/rt/itcms/Object#set:color (param $this i32) (param $color i32) + local.get $this + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $color + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + ) + (func $~lib/rt/itcms/Object#get:prev (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/rt/itcms/Object#set:next (param $this i32) (param $obj i32) + local.get $this + local.get $obj + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.and + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + ) + (func $~lib/rt/itcms/Object#unlink (param $this i32) + (local $next i32) + (local $prev i32) + local.get $this + call $~lib/rt/itcms/Object#get:next + local.set $next + local.get $next + i32.const 0 + i32.eq + if + i32.const 1 + drop + local.get $this + call $~lib/rt/itcms/Object#get:prev + i32.const 0 + i32.eq + if (result i32) + local.get $this + global.get $~lib/memory/__heap_base + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 128 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + return + end + local.get $this + call $~lib/rt/itcms/Object#get:prev + local.set $prev + i32.const 1 + drop + local.get $prev + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 132 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $next + local.get $prev + call $~lib/rt/itcms/Object#set:prev + local.get $prev + local.get $next + call $~lib/rt/itcms/Object#set:next + ) + (func $~lib/rt/itcms/Object#get:rtId (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/shared/typeinfo/Typeinfo#get:flags (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/__typeinfo (param $id i32) (result i32) + (local $ptr i32) + global.get $~lib/rt/__rtti_base + local.set $ptr + local.get $id + local.get $ptr + i32.load + i32.gt_u + if + i32.const 480 + i32.const 544 + i32.const 21 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $ptr + i32.const 4 + i32.add + local.get $id + i32.const 4 + i32.mul + i32.add + call $~lib/shared/typeinfo/Typeinfo#get:flags + return + ) + (func $~lib/rt/itcms/Object#get:isPointerfree (param $this i32) (result i32) + (local $rtId i32) + local.get $this + call $~lib/rt/itcms/Object#get:rtId + local.set $rtId + local.get $rtId + i32.const 2 + i32.le_u + if (result i32) + i32.const 1 + else + local.get $rtId + call $~lib/rt/__typeinfo + i32.const 32 + i32.and + i32.const 0 + i32.ne + end + return + ) + (func $~lib/rt/itcms/Object#linkTo (param $this i32) (param $list i32) (param $withColor i32) + (local $prev i32) + local.get $list + call $~lib/rt/itcms/Object#get:prev + local.set $prev + local.get $this + local.get $list + local.get $withColor + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $this + local.get $prev + call $~lib/rt/itcms/Object#set:prev + local.get $prev + local.get $this + call $~lib/rt/itcms/Object#set:next + local.get $list + local.get $this + call $~lib/rt/itcms/Object#set:prev + ) + (func $~lib/rt/itcms/Object#makeGray (param $this i32) + (local $1 i32) + local.get $this + global.get $~lib/rt/itcms/iter + i32.eq + if + local.get $this + call $~lib/rt/itcms/Object#get:prev + local.tee $1 + i32.eqz + if (result i32) + i32.const 0 + i32.const 352 + i32.const 148 + i32.const 30 + call $~lib/builtins/abort + unreachable + else + local.get $1 + end + global.set $~lib/rt/itcms/iter + end + local.get $this + call $~lib/rt/itcms/Object#unlink + local.get $this + global.get $~lib/rt/itcms/toSpace + local.get $this + call $~lib/rt/itcms/Object#get:isPointerfree + if (result i32) + global.get $~lib/rt/itcms/white + i32.eqz + else + i32.const 2 + end + call $~lib/rt/itcms/Object#linkTo + ) + (func $~lib/rt/itcms/__visit (param $ptr i32) (param $cookie i32) + (local $obj i32) + local.get $ptr + i32.eqz + if + return + end + local.get $ptr + i32.const 20 + i32.sub + local.set $obj + i32.const 0 + drop + local.get $obj + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eq + if + local.get $obj + call $~lib/rt/itcms/Object#makeGray + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.add + global.set $~lib/rt/itcms/visitCount + end + ) + (func $~lib/rt/itcms/visitStack (param $cookie i32) + (local $ptr i32) + global.get $~lib/memory/__stack_pointer + local.set $ptr + loop $while-continue|0 + local.get $ptr + global.get $~lib/memory/__heap_base + i32.lt_u + if + local.get $ptr + i32.load + local.get $cookie + call $~lib/rt/itcms/__visit + local.get $ptr + i32.const 4 + i32.add + local.set $ptr + br $while-continue|0 + end + end + ) + (func $~lib/rt/common/BLOCK#get:mmInfo (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/itcms/Object#get:size (param $this i32) (result i32) + i32.const 4 + local.get $this + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + return + ) + (func $~lib/rt/tlsf/Root#set:flMap (param $this i32) (param $flMap i32) + local.get $this + local.get $flMap + i32.store + ) + (func $~lib/rt/common/BLOCK#set:mmInfo (param $this i32) (param $mmInfo i32) + local.get $this + local.get $mmInfo + i32.store + ) + (func $~lib/rt/tlsf/Block#set:prev (param $this i32) (param $prev i32) + local.get $this + local.get $prev + i32.store offset=4 + ) + (func $~lib/rt/tlsf/Block#set:next (param $this i32) (param $next i32) + local.get $this + local.get $next + i32.store offset=8 + ) + (func $~lib/rt/tlsf/Block#get:prev (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/rt/tlsf/Block#get:next (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/rt/tlsf/Root#get:flMap (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/tlsf/removeBlock (param $root i32) (param $block i32) + (local $blockInfo i32) + (local $size i32) + (local $fl i32) + (local $sl i32) + (local $6 i32) + (local $7 i32) + (local $boundedSize i32) + (local $prev i32) + (local $next i32) + (local $root|11 i32) + (local $fl|12 i32) + (local $sl|13 i32) + (local $root|14 i32) + (local $fl|15 i32) + (local $sl|16 i32) + (local $head i32) + (local $root|18 i32) + (local $fl|19 i32) + (local $slMap i32) + (local $root|21 i32) + (local $fl|22 i32) + (local $slMap|23 i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $blockInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 268 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.set $size + i32.const 1 + drop + local.get $size + i32.const 12 + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 270 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + local.tee $6 + i32.const 1073741820 + local.tee $7 + local.get $6 + local.get $7 + i32.lt_u + select + local.set $boundedSize + i32.const 31 + local.get $boundedSize + i32.clz + i32.sub + local.set $fl + local.get $boundedSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 284 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $block + call $~lib/rt/tlsf/Block#get:prev + local.set $prev + local.get $block + call $~lib/rt/tlsf/Block#get:next + local.set $next + local.get $prev + if + local.get $prev + local.get $next + call $~lib/rt/tlsf/Block#set:next + end + local.get $next + if + local.get $next + local.get $prev + call $~lib/rt/tlsf/Block#set:prev + end + local.get $block + block $~lib/rt/tlsf/GETHEAD|inlined.0 (result i32) + local.get $root + local.set $root|11 + local.get $fl + local.set $fl|12 + local.get $sl + local.set $sl|13 + local.get $root|11 + local.get $fl|12 + i32.const 4 + i32.shl + local.get $sl|13 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.0 + end + i32.eq + if + local.get $root + local.set $root|14 + local.get $fl + local.set $fl|15 + local.get $sl + local.set $sl|16 + local.get $next + local.set $head + local.get $root|14 + local.get $fl|15 + i32.const 4 + i32.shl + local.get $sl|16 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head + i32.store offset=96 + local.get $next + i32.eqz + if + block $~lib/rt/tlsf/GETSL|inlined.0 (result i32) + local.get $root + local.set $root|18 + local.get $fl + local.set $fl|19 + local.get $root|18 + local.get $fl|19 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.0 + end + local.set $slMap + local.get $root + local.set $root|21 + local.get $fl + local.set $fl|22 + local.get $slMap + i32.const 1 + local.get $sl + i32.shl + i32.const -1 + i32.xor + i32.and + local.tee $slMap + local.set $slMap|23 + local.get $root|21 + local.get $fl|22 + i32.const 2 + i32.shl + i32.add + local.get $slMap|23 + i32.store offset=4 + local.get $slMap + i32.eqz + if + local.get $root + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 1 + local.get $fl + i32.shl + i32.const -1 + i32.xor + i32.and + call $~lib/rt/tlsf/Root#set:flMap + end + end + end + ) + (func $~lib/rt/tlsf/insertBlock (param $root i32) (param $block i32) + (local $blockInfo i32) + (local $block|3 i32) + (local $right i32) + (local $rightInfo i32) + (local $block|6 i32) + (local $block|7 i32) + (local $left i32) + (local $leftInfo i32) + (local $size i32) + (local $fl i32) + (local $sl i32) + (local $13 i32) + (local $14 i32) + (local $boundedSize i32) + (local $root|16 i32) + (local $fl|17 i32) + (local $sl|18 i32) + (local $head i32) + (local $root|20 i32) + (local $fl|21 i32) + (local $sl|22 i32) + (local $head|23 i32) + (local $root|24 i32) + (local $fl|25 i32) + (local $root|26 i32) + (local $fl|27 i32) + (local $slMap i32) + i32.const 1 + drop + local.get $block + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 201 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $blockInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 203 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETRIGHT|inlined.0 (result i32) + local.get $block + local.set $block|3 + local.get $block|3 + i32.const 4 + i32.add + local.get $block|3 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.0 + end + local.set $right + local.get $right + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $rightInfo + local.get $rightInfo + i32.const 1 + i32.and + if + local.get $root + local.get $right + call $~lib/rt/tlsf/removeBlock + local.get $block + local.get $blockInfo + i32.const 4 + i32.add + local.get $rightInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + local.tee $blockInfo + call $~lib/rt/common/BLOCK#set:mmInfo + block $~lib/rt/tlsf/GETRIGHT|inlined.1 (result i32) + local.get $block + local.set $block|6 + local.get $block|6 + i32.const 4 + i32.add + local.get $block|6 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.1 + end + local.set $right + local.get $right + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $rightInfo + end + local.get $blockInfo + i32.const 2 + i32.and + if + block $~lib/rt/tlsf/GETFREELEFT|inlined.0 (result i32) + local.get $block + local.set $block|7 + local.get $block|7 + i32.const 4 + i32.sub + i32.load + br $~lib/rt/tlsf/GETFREELEFT|inlined.0 + end + local.set $left + local.get $left + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $leftInfo + i32.const 1 + drop + local.get $leftInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 221 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $root + local.get $left + call $~lib/rt/tlsf/removeBlock + local.get $left + local.set $block + local.get $block + local.get $leftInfo + i32.const 4 + i32.add + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + local.tee $blockInfo + call $~lib/rt/common/BLOCK#set:mmInfo + end + local.get $right + local.get $rightInfo + i32.const 2 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.set $size + i32.const 1 + drop + local.get $size + i32.const 12 + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 233 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + i32.const 1 + drop + local.get $block + i32.const 4 + i32.add + local.get $size + i32.add + local.get $right + i32.eq + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 234 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $right + i32.const 4 + i32.sub + local.get $block + i32.store + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + local.tee $13 + i32.const 1073741820 + local.tee $14 + local.get $13 + local.get $14 + i32.lt_u + select + local.set $boundedSize + i32.const 31 + local.get $boundedSize + i32.clz + i32.sub + local.set $fl + local.get $boundedSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 251 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETHEAD|inlined.1 (result i32) + local.get $root + local.set $root|16 + local.get $fl + local.set $fl|17 + local.get $sl + local.set $sl|18 + local.get $root|16 + local.get $fl|17 + i32.const 4 + i32.shl + local.get $sl|18 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.1 + end + local.set $head + local.get $block + i32.const 0 + call $~lib/rt/tlsf/Block#set:prev + local.get $block + local.get $head + call $~lib/rt/tlsf/Block#set:next + local.get $head + if + local.get $head + local.get $block + call $~lib/rt/tlsf/Block#set:prev + end + local.get $root + local.set $root|20 + local.get $fl + local.set $fl|21 + local.get $sl + local.set $sl|22 + local.get $block + local.set $head|23 + local.get $root|20 + local.get $fl|21 + i32.const 4 + i32.shl + local.get $sl|22 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head|23 + i32.store offset=96 + local.get $root + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 1 + local.get $fl + i32.shl + i32.or + call $~lib/rt/tlsf/Root#set:flMap + local.get $root + local.set $root|26 + local.get $fl + local.set $fl|27 + block $~lib/rt/tlsf/GETSL|inlined.1 (result i32) + local.get $root + local.set $root|24 + local.get $fl + local.set $fl|25 + local.get $root|24 + local.get $fl|25 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.1 + end + i32.const 1 + local.get $sl + i32.shl + i32.or + local.set $slMap + local.get $root|26 + local.get $fl|27 + i32.const 2 + i32.shl + i32.add + local.get $slMap + i32.store offset=4 + ) + (func $~lib/rt/tlsf/addMemory (param $root i32) (param $start i32) (param $endU64 i64) (result i32) + (local $end i32) + (local $root|4 i32) + (local $tail i32) + (local $tailInfo i32) + (local $size i32) + (local $leftSize i32) + (local $left i32) + (local $root|10 i32) + (local $tail|11 i32) + local.get $endU64 + i32.wrap_i64 + local.set $end + i32.const 1 + drop + local.get $start + i64.extend_i32_u + local.get $endU64 + i64.le_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 382 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $start + i32.const 4 + i32.add + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + i32.const 4 + i32.sub + local.set $start + local.get $end + i32.const 15 + i32.const -1 + i32.xor + i32.and + local.set $end + block $~lib/rt/tlsf/GETTAIL|inlined.0 (result i32) + local.get $root + local.set $root|4 + local.get $root|4 + i32.load offset=1568 + br $~lib/rt/tlsf/GETTAIL|inlined.0 + end + local.set $tail + i32.const 0 + local.set $tailInfo + local.get $tail + if + i32.const 1 + drop + local.get $start + local.get $tail + i32.const 4 + i32.add + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 389 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $start + i32.const 16 + i32.sub + local.get $tail + i32.eq + if + local.get $start + i32.const 16 + i32.sub + local.set $start + local.get $tail + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $tailInfo + else + end + else + i32.const 1 + drop + local.get $start + local.get $root + i32.const 1572 + i32.add + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 402 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + end + local.get $end + local.get $start + i32.sub + local.set $size + local.get $size + i32.const 4 + i32.const 12 + i32.add + i32.const 4 + i32.add + i32.lt_u + if + i32.const 0 + return + end + local.get $size + i32.const 2 + i32.const 4 + i32.mul + i32.sub + local.set $leftSize + local.get $start + local.set $left + local.get $left + local.get $leftSize + i32.const 1 + i32.or + local.get $tailInfo + i32.const 2 + i32.and + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $left + i32.const 0 + call $~lib/rt/tlsf/Block#set:prev + local.get $left + i32.const 0 + call $~lib/rt/tlsf/Block#set:next + local.get $start + i32.const 4 + i32.add + local.get $leftSize + i32.add + local.set $tail + local.get $tail + i32.const 0 + i32.const 2 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.set $root|10 + local.get $tail + local.set $tail|11 + local.get $root|10 + local.get $tail|11 + i32.store offset=1568 + local.get $root + local.get $left + call $~lib/rt/tlsf/insertBlock + i32.const 1 + return + ) + (func $~lib/rt/tlsf/initialize + (local $rootOffset i32) + (local $pagesBefore i32) + (local $pagesNeeded i32) + (local $root i32) + (local $root|4 i32) + (local $tail i32) + (local $fl i32) + (local $root|7 i32) + (local $fl|8 i32) + (local $slMap i32) + (local $sl i32) + (local $root|11 i32) + (local $fl|12 i32) + (local $sl|13 i32) + (local $head i32) + (local $memStart i32) + i32.const 0 + drop + global.get $~lib/memory/__heap_base + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + local.set $rootOffset + memory.size + local.set $pagesBefore + local.get $rootOffset + i32.const 1572 + i32.add + i32.const 65535 + i32.add + i32.const 65535 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.shr_u + local.set $pagesNeeded + local.get $pagesNeeded + local.get $pagesBefore + i32.gt_s + if (result i32) + local.get $pagesNeeded + local.get $pagesBefore + i32.sub + memory.grow + i32.const 0 + i32.lt_s + else + i32.const 0 + end + if + unreachable + end + local.get $rootOffset + local.set $root + local.get $root + i32.const 0 + call $~lib/rt/tlsf/Root#set:flMap + local.get $root + local.set $root|4 + i32.const 0 + local.set $tail + local.get $root|4 + local.get $tail + i32.store offset=1568 + i32.const 0 + local.set $fl + loop $for-loop|0 + local.get $fl + i32.const 23 + i32.lt_u + if + local.get $root + local.set $root|7 + local.get $fl + local.set $fl|8 + i32.const 0 + local.set $slMap + local.get $root|7 + local.get $fl|8 + i32.const 2 + i32.shl + i32.add + local.get $slMap + i32.store offset=4 + i32.const 0 + local.set $sl + loop $for-loop|1 + local.get $sl + i32.const 16 + i32.lt_u + if + local.get $root + local.set $root|11 + local.get $fl + local.set $fl|12 + local.get $sl + local.set $sl|13 + i32.const 0 + local.set $head + local.get $root|11 + local.get $fl|12 + i32.const 4 + i32.shl + local.get $sl|13 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head + i32.store offset=96 + local.get $sl + i32.const 1 + i32.add + local.set $sl + br $for-loop|1 + end + end + local.get $fl + i32.const 1 + i32.add + local.set $fl + br $for-loop|0 + end + end + local.get $rootOffset + i32.const 1572 + i32.add + local.set $memStart + i32.const 0 + drop + local.get $root + local.get $memStart + memory.size + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + drop + local.get $root + global.set $~lib/rt/tlsf/ROOT + ) + (func $~lib/rt/tlsf/checkUsedBlock (param $ptr i32) (result i32) + (local $block i32) + local.get $ptr + i32.const 4 + i32.sub + local.set $block + local.get $ptr + i32.const 0 + i32.ne + if (result i32) + local.get $ptr + i32.const 15 + i32.and + i32.eqz + else + i32.const 0 + end + if (result i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 1 + i32.and + i32.eqz + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 562 + i32.const 3 + call $~lib/builtins/abort + unreachable + end + local.get $block + return + ) + (func $~lib/rt/tlsf/freeBlock (param $root i32) (param $block i32) + i32.const 0 + drop + local.get $block + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 1 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.get $block + call $~lib/rt/tlsf/insertBlock + ) + (func $~lib/rt/tlsf/__free (param $ptr i32) + local.get $ptr + global.get $~lib/memory/__heap_base + i32.lt_u + if + return + end + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $ptr + call $~lib/rt/tlsf/checkUsedBlock + call $~lib/rt/tlsf/freeBlock + ) + (func $~lib/rt/itcms/free (param $obj i32) + local.get $obj + global.get $~lib/memory/__heap_base + i32.lt_u + if + local.get $obj + i32.const 0 + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $obj + i32.const 0 + call $~lib/rt/itcms/Object#set:prev + else + global.get $~lib/rt/itcms/total + local.get $obj + call $~lib/rt/itcms/Object#get:size + i32.sub + global.set $~lib/rt/itcms/total + i32.const 0 + drop + local.get $obj + i32.const 4 + i32.add + call $~lib/rt/tlsf/__free + end + ) + (func $~lib/rt/itcms/step (result i32) + (local $obj i32) + (local $1 i32) + (local $black i32) + (local $from i32) + block $break|0 + block $case2|0 + block $case1|0 + block $case0|0 + global.get $~lib/rt/itcms/state + local.set $1 + local.get $1 + i32.const 0 + i32.eq + br_if $case0|0 + local.get $1 + i32.const 1 + i32.eq + br_if $case1|0 + local.get $1 + i32.const 2 + i32.eq + br_if $case2|0 + br $break|0 + end + i32.const 1 + global.set $~lib/rt/itcms/state + i32.const 0 + global.set $~lib/rt/itcms/visitCount + i32.const 0 + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/iter + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + global.get $~lib/rt/itcms/white + i32.eqz + local.set $black + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + loop $while-continue|1 + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + global.set $~lib/rt/itcms/iter + local.get $obj + call $~lib/rt/itcms/Object#get:color + local.get $black + i32.ne + if + local.get $obj + local.get $black + call $~lib/rt/itcms/Object#set:color + i32.const 0 + global.set $~lib/rt/itcms/visitCount + local.get $obj + i32.const 20 + i32.add + i32.const 0 + call $~lib/rt/__visit_members + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + local.get $obj + call $~lib/rt/itcms/Object#get:next + local.set $obj + br $while-continue|1 + end + end + i32.const 0 + global.set $~lib/rt/itcms/visitCount + i32.const 0 + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.eq + if + i32.const 0 + call $~lib/rt/itcms/visitStack + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + loop $while-continue|2 + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + call $~lib/rt/itcms/Object#get:color + local.get $black + i32.ne + if + local.get $obj + local.get $black + call $~lib/rt/itcms/Object#set:color + local.get $obj + i32.const 20 + i32.add + i32.const 0 + call $~lib/rt/__visit_members + end + local.get $obj + call $~lib/rt/itcms/Object#get:next + local.set $obj + br $while-continue|2 + end + end + global.get $~lib/rt/itcms/fromSpace + local.set $from + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/fromSpace + local.get $from + global.set $~lib/rt/itcms/toSpace + local.get $black + global.set $~lib/rt/itcms/white + local.get $from + call $~lib/rt/itcms/Object#get:next + global.set $~lib/rt/itcms/iter + i32.const 2 + global.set $~lib/rt/itcms/state + end + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + global.get $~lib/rt/itcms/iter + local.set $obj + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + call $~lib/rt/itcms/Object#get:next + global.set $~lib/rt/itcms/iter + i32.const 1 + drop + local.get $obj + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eqz + i32.eq + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 229 + i32.const 20 + call $~lib/builtins/abort + unreachable + end + local.get $obj + call $~lib/rt/itcms/free + i32.const 10 + return + end + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + call $~lib/rt/itcms/Object#set:nextWithColor + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + call $~lib/rt/itcms/Object#set:prev + i32.const 0 + global.set $~lib/rt/itcms/state + br $break|0 + end + i32.const 0 + return + ) + (func $~lib/rt/itcms/interrupt + (local $budget i32) + i32.const 0 + drop + i32.const 0 + drop + i32.const 1024 + i32.const 200 + i32.mul + i32.const 100 + i32.div_u + local.set $budget + loop $do-loop|0 + local.get $budget + call $~lib/rt/itcms/step + i32.sub + local.set $budget + global.get $~lib/rt/itcms/state + i32.const 0 + i32.eq + if + i32.const 0 + drop + global.get $~lib/rt/itcms/total + i64.extend_i32_u + i32.const 200 + i64.extend_i32_u + i64.mul + i64.const 100 + i64.div_u + i32.wrap_i64 + i32.const 1024 + i32.add + global.set $~lib/rt/itcms/threshold + i32.const 0 + drop + return + end + local.get $budget + i32.const 0 + i32.gt_s + br_if $do-loop|0 + end + i32.const 0 + drop + global.get $~lib/rt/itcms/total + i32.const 1024 + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.sub + i32.const 1024 + i32.lt_u + i32.mul + i32.add + global.set $~lib/rt/itcms/threshold + i32.const 0 + drop + ) + (func $~lib/rt/tlsf/computeSize (param $size i32) (result i32) + local.get $size + i32.const 12 + i32.le_u + if (result i32) + i32.const 12 + else + local.get $size + i32.const 4 + i32.add + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + i32.const 4 + i32.sub + end + return + ) + (func $~lib/rt/tlsf/prepareSize (param $size i32) (result i32) + local.get $size + i32.const 1073741820 + i32.gt_u + if + i32.const 288 + i32.const 624 + i32.const 461 + i32.const 29 + call $~lib/builtins/abort + unreachable + end + local.get $size + call $~lib/rt/tlsf/computeSize + return + ) + (func $~lib/rt/tlsf/roundSize (param $size i32) (result i32) + local.get $size + i32.const 536870910 + i32.lt_u + if (result i32) + local.get $size + i32.const 1 + i32.const 27 + local.get $size + i32.clz + i32.sub + i32.shl + i32.add + i32.const 1 + i32.sub + else + local.get $size + end + return + ) + (func $~lib/rt/tlsf/searchBlock (param $root i32) (param $size i32) (result i32) + (local $fl i32) + (local $sl i32) + (local $requestSize i32) + (local $root|5 i32) + (local $fl|6 i32) + (local $slMap i32) + (local $head i32) + (local $flMap i32) + (local $root|10 i32) + (local $fl|11 i32) + (local $root|12 i32) + (local $fl|13 i32) + (local $sl|14 i32) + (local $root|15 i32) + (local $fl|16 i32) + (local $sl|17 i32) + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + call $~lib/rt/tlsf/roundSize + local.set $requestSize + i32.const 4 + i32.const 8 + i32.mul + i32.const 1 + i32.sub + local.get $requestSize + i32.clz + i32.sub + local.set $fl + local.get $requestSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 334 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETSL|inlined.2 (result i32) + local.get $root + local.set $root|5 + local.get $fl + local.set $fl|6 + local.get $root|5 + local.get $fl|6 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.2 + end + i32.const 0 + i32.const -1 + i32.xor + local.get $sl + i32.shl + i32.and + local.set $slMap + i32.const 0 + local.set $head + local.get $slMap + i32.eqz + if + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 0 + i32.const -1 + i32.xor + local.get $fl + i32.const 1 + i32.add + i32.shl + i32.and + local.set $flMap + local.get $flMap + i32.eqz + if + i32.const 0 + local.set $head + else + local.get $flMap + i32.ctz + local.set $fl + block $~lib/rt/tlsf/GETSL|inlined.3 (result i32) + local.get $root + local.set $root|10 + local.get $fl + local.set $fl|11 + local.get $root|10 + local.get $fl|11 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.3 + end + local.set $slMap + i32.const 1 + drop + local.get $slMap + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 347 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETHEAD|inlined.2 (result i32) + local.get $root + local.set $root|12 + local.get $fl + local.set $fl|13 + local.get $slMap + i32.ctz + local.set $sl|14 + local.get $root|12 + local.get $fl|13 + i32.const 4 + i32.shl + local.get $sl|14 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.2 + end + local.set $head + end + else + block $~lib/rt/tlsf/GETHEAD|inlined.3 (result i32) + local.get $root + local.set $root|15 + local.get $fl + local.set $fl|16 + local.get $slMap + i32.ctz + local.set $sl|17 + local.get $root|15 + local.get $fl|16 + i32.const 4 + i32.shl + local.get $sl|17 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.3 + end + local.set $head + end + local.get $head + return + ) + (func $~lib/rt/tlsf/growMemory (param $root i32) (param $size i32) + (local $pagesBefore i32) + (local $root|3 i32) + (local $pagesNeeded i32) + (local $5 i32) + (local $6 i32) + (local $pagesWanted i32) + (local $pagesAfter i32) + i32.const 0 + drop + local.get $size + i32.const 256 + i32.ge_u + if + local.get $size + call $~lib/rt/tlsf/roundSize + local.set $size + end + memory.size + local.set $pagesBefore + local.get $size + i32.const 4 + local.get $pagesBefore + i32.const 16 + i32.shl + i32.const 4 + i32.sub + block $~lib/rt/tlsf/GETTAIL|inlined.1 (result i32) + local.get $root + local.set $root|3 + local.get $root|3 + i32.load offset=1568 + br $~lib/rt/tlsf/GETTAIL|inlined.1 + end + i32.ne + i32.shl + i32.add + local.set $size + local.get $size + i32.const 65535 + i32.add + i32.const 65535 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.shr_u + local.set $pagesNeeded + local.get $pagesBefore + local.tee $5 + local.get $pagesNeeded + local.tee $6 + local.get $5 + local.get $6 + i32.gt_s + select + local.set $pagesWanted + local.get $pagesWanted + memory.grow + i32.const 0 + i32.lt_s + if + local.get $pagesNeeded + memory.grow + i32.const 0 + i32.lt_s + if + unreachable + end + end + memory.size + local.set $pagesAfter + local.get $root + local.get $pagesBefore + i32.const 16 + i32.shl + local.get $pagesAfter + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + drop + ) + (func $~lib/rt/tlsf/prepareBlock (param $root i32) (param $block i32) (param $size i32) + (local $blockInfo i32) + (local $remaining i32) + (local $spare i32) + (local $block|6 i32) + (local $block|7 i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $size + i32.const 4 + i32.add + i32.const 15 + i32.and + i32.eqz + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 361 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $size + i32.sub + local.set $remaining + local.get $remaining + i32.const 4 + i32.const 12 + i32.add + i32.ge_u + if + local.get $block + local.get $size + local.get $blockInfo + i32.const 2 + i32.and + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $block + i32.const 4 + i32.add + local.get $size + i32.add + local.set $spare + local.get $spare + local.get $remaining + i32.const 4 + i32.sub + i32.const 1 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.get $spare + call $~lib/rt/tlsf/insertBlock + else + local.get $block + local.get $blockInfo + i32.const 1 + i32.const -1 + i32.xor + i32.and + call $~lib/rt/common/BLOCK#set:mmInfo + block $~lib/rt/tlsf/GETRIGHT|inlined.3 (result i32) + local.get $block + local.set $block|7 + local.get $block|7 + i32.const 4 + i32.add + local.get $block|7 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.3 + end + block $~lib/rt/tlsf/GETRIGHT|inlined.2 (result i32) + local.get $block + local.set $block|6 + local.get $block|6 + i32.const 4 + i32.add + local.get $block|6 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.2 + end + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 2 + i32.const -1 + i32.xor + i32.and + call $~lib/rt/common/BLOCK#set:mmInfo + end + ) + (func $~lib/rt/tlsf/allocateBlock (param $root i32) (param $size i32) (result i32) + (local $payloadSize i32) + (local $block i32) + local.get $size + call $~lib/rt/tlsf/prepareSize + local.set $payloadSize + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/searchBlock + local.set $block + local.get $block + i32.eqz + if + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/growMemory + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/searchBlock + local.set $block + i32.const 1 + drop + local.get $block + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 499 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + end + i32.const 1 + drop + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $payloadSize + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 501 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $root + local.get $block + call $~lib/rt/tlsf/removeBlock + local.get $root + local.get $block + local.get $payloadSize + call $~lib/rt/tlsf/prepareBlock + i32.const 0 + drop + local.get $block + return + ) + (func $~lib/rt/tlsf/__alloc (param $size i32) (result i32) + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $size + call $~lib/rt/tlsf/allocateBlock + i32.const 4 + i32.add + return + ) + (func $~lib/rt/itcms/Object#set:rtId (param $this i32) (param $rtId i32) + local.get $this + local.get $rtId + i32.store offset=12 + ) + (func $~lib/rt/itcms/Object#set:rtSize (param $this i32) (param $rtSize i32) + local.get $this + local.get $rtSize + i32.store offset=16 + ) + (func $~lib/rt/itcms/__new (param $size i32) (param $id i32) (result i32) + (local $obj i32) + (local $ptr i32) + local.get $size + i32.const 1073741804 + i32.ge_u + if + i32.const 288 + i32.const 352 + i32.const 261 + i32.const 31 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.ge_u + if + call $~lib/rt/itcms/interrupt + end + i32.const 16 + local.get $size + i32.add + call $~lib/rt/tlsf/__alloc + i32.const 4 + i32.sub + local.set $obj + local.get $obj + local.get $id + call $~lib/rt/itcms/Object#set:rtId + local.get $obj + local.get $size + call $~lib/rt/itcms/Object#set:rtSize + local.get $obj + global.get $~lib/rt/itcms/fromSpace + global.get $~lib/rt/itcms/white + call $~lib/rt/itcms/Object#linkTo + global.get $~lib/rt/itcms/total + local.get $obj + call $~lib/rt/itcms/Object#get:size + i32.add + global.set $~lib/rt/itcms/total + local.get $obj + i32.const 20 + i32.add + local.set $ptr + local.get $ptr + i32.const 0 + local.get $size + memory.fill + local.get $ptr + return + ) + (func $assembly/arguments/Args#set:a (param $this i32) (param $a i32) + local.get $this + local.get $a + i32.store + ) + (func $assembly/arguments/Args#set:b (param $this i32) (param $b i32) + local.get $this + local.get $b + i32.store offset=4 + ) + (func $assembly/arguments/Args#set:c (param $this i32) (param $c i32) + local.get $this + local.get $c + i32.store offset=8 + ) + (func $assembly/arguments/Args#set:d (param $this i32) (param $d i32) + local.get $this + local.get $d + i32.store offset=12 + ) + (func $start:assembly/arguments~anonymous|0 (param $_d i32) (param $_l i32) (result i32) + i32.const 0 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + return + ) + (func $~lib/arraybuffer/ArrayBufferView#get:byteLength (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/arraybuffer/ArrayBufferView#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/itcms/__link (param $parentPtr i32) (param $childPtr i32) (param $expectMultiple i32) + (local $child i32) + (local $parent i32) + (local $parentColor i32) + local.get $childPtr + i32.eqz + if + return + end + i32.const 1 + drop + local.get $parentPtr + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 295 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $childPtr + i32.const 20 + i32.sub + local.set $child + local.get $child + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eq + if + local.get $parentPtr + i32.const 20 + i32.sub + local.set $parent + local.get $parent + call $~lib/rt/itcms/Object#get:color + local.set $parentColor + local.get $parentColor + global.get $~lib/rt/itcms/white + i32.eqz + i32.eq + if + local.get $expectMultiple + if + local.get $parent + call $~lib/rt/itcms/Object#makeGray + else + local.get $child + call $~lib/rt/itcms/Object#makeGray + end + else + local.get $parentColor + i32.const 3 + i32.eq + if (result i32) + global.get $~lib/rt/itcms/state + i32.const 1 + i32.eq + else + i32.const 0 + end + if + local.get $child + call $~lib/rt/itcms/Object#makeGray + end + end + end + ) + (func $~lib/arraybuffer/ArrayBufferView#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/arguments/Nibbles#set:low (param $this i32) (param $low i32) + local.get $this + local.get $low + i32.store8 + ) + (func $assembly/arguments/Nibbles#set:hig (param $this i32) (param $hig i32) + local.get $this + local.get $hig + i32.store8 offset=1 + ) + (func $assembly/arguments/Nibbles#get:low (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/arguments/Nibbles#get:hig (param $this i32) (result i32) + local.get $this + i32.load8_u offset=1 + ) + (func $assembly/arguments/Args#get:a (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/arguments/Args#get:b (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $start:assembly/arguments + (local $0 i32) + (local $1 i32) + (local $2 i32) + memory.size + i32.const 16 + i32.shl + global.get $~lib/memory/__heap_base + i32.sub + i32.const 1 + i32.shr_u + global.set $~lib/rt/itcms/threshold + i32.const 400 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/pinSpace + i32.const 432 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/toSpace + i32.const 576 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/fromSpace + ) + (func $~lib/math/ipow32 (param $x i32) (param $e i32) (result i32) + (local $out i32) + (local $log i32) + (local $4 i32) + i32.const 1 + local.set $out + i32.const 0 + i32.const 1 + i32.lt_s + drop + local.get $x + i32.const 2 + i32.eq + if + i32.const 1 + local.get $e + i32.shl + i32.const 0 + local.get $e + i32.const 32 + i32.lt_u + select + return + end + local.get $e + i32.const 0 + i32.le_s + if + local.get $x + i32.const -1 + i32.eq + if + i32.const -1 + i32.const 1 + local.get $e + i32.const 1 + i32.and + select + return + end + local.get $e + i32.const 0 + i32.eq + local.get $x + i32.const 1 + i32.eq + i32.or + return + else + local.get $e + i32.const 1 + i32.eq + if + local.get $x + return + else + local.get $e + i32.const 2 + i32.eq + if + local.get $x + local.get $x + i32.mul + return + else + local.get $e + i32.const 32 + i32.lt_s + if + i32.const 32 + local.get $e + i32.clz + i32.sub + local.set $log + block $break|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $log + local.set $4 + local.get $4 + i32.const 5 + i32.eq + br_if $case0|0 + local.get $4 + i32.const 4 + i32.eq + br_if $case1|0 + local.get $4 + i32.const 3 + i32.eq + br_if $case2|0 + local.get $4 + i32.const 2 + i32.eq + br_if $case3|0 + local.get $4 + i32.const 1 + i32.eq + br_if $case4|0 + br $break|0 + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + end + local.get $out + return + end + end + end + end + loop $while-continue|1 + local.get $e + if + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + br $while-continue|1 + end + end + local.get $out + return + ) + (func $start:assembly/memory-page + i32.const 2 + i32.const 16 + call $~lib/math/ipow32 + global.set $assembly/memory-page/SEGMENT_SIZE + global.get $assembly/memory-page/SEGMENT_SIZE + global.set $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/PAGE_SIZE + i32.div_u + global.set $assembly/memory-page/RESERVED_PAGES + i32.const 2 + i32.const 29 + call $~lib/math/ipow32 + global.set $assembly/memory-page/ALLOCATE_EAGERLY + ) + (func $assembly/memory/MaybePageFault#set:isFault (param $this i32) (param $isFault i32) + local.get $this + local.get $isFault + i32.store8 + ) + (func $assembly/memory/MaybePageFault#set:isAccess (param $this i32) (param $isAccess i32) + local.get $this + local.get $isAccess + i32.store8 offset=1 + ) + (func $assembly/memory/MaybePageFault#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store offset=4 + ) + (func $~lib/arraybuffer/ArrayBufferView#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/arraybuffer/ArrayBufferView#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/arraybuffer/ArrayBufferView#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $assembly/memory-page/Page#set:access (param $this i32) (param $access i32) + local.get $this + local.get $access + i32.store + ) + (func $assembly/memory-page/Page#set:raw (param $this i32) (param $raw i32) + local.get $this + local.get $raw + i32.store offset=4 + local.get $this + local.get $raw + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory-page/RawPage#set:id (param $this i32) (param $id i32) + local.get $this + local.get $id + i32.store + ) + (func $assembly/memory-page/RawPage#set:page (param $this i32) (param $page i32) + local.get $this + local.get $page + i32.store offset=4 + local.get $this + local.get $page + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/instructions/utils/reg (param $v i64) (result i32) + local.get $v + global.get $assembly/registers/NO_OF_REGISTERS + i64.extend_i32_s + i64.ge_u + if (result i32) + global.get $assembly/registers/NO_OF_REGISTERS + i32.const 1 + i32.sub + else + local.get $v + i32.wrap_i64 + end + return + ) + (func $~lib/rt/common/OBJECT#get:rtSize (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 3 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i64) + local.get $this + local.get $index + i32.const 3 + i32.shl + i32.add + local.get $value + i64.store + i32.const 0 + drop + ) + (func $assembly/instructions/outcome/OutcomeData#set:outcome (param $this i32) (param $outcome i32) + local.get $this + local.get $outcome + i32.store + ) + (func $assembly/instructions/outcome/OutcomeData#set:staticJump (param $this i32) (param $staticJump i32) + local.get $this + local.get $staticJump + i32.store offset=4 + ) + (func $assembly/instructions/outcome/OutcomeData#set:dJump (param $this i32) (param $dJump i32) + local.get $this + local.get $dJump + i32.store offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#set:result (param $this i32) (param $result i32) + local.get $this + local.get $result + i32.store offset=12 + ) + (func $assembly/instructions/outcome/OutcomeData#set:exitCode (param $this i32) (param $exitCode i32) + local.get $this + local.get $exitCode + i32.store offset=16 + ) + (func $assembly/instructions/outcome/ok (result i32) + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + return + ) + (func $assembly/instructions/utils/u8SignExtend (param $v i32) (result i64) + local.get $v + i32.extend8_s + i64.extend_i32_s + return + ) + (func $assembly/instructions/utils/u16SignExtend (param $v i32) (result i64) + local.get $v + i32.extend16_s + i64.extend_i32_s + return + ) + (func $~lib/polyfills/bswap (param $value i64) (result i64) + (local $a i64) + (local $b i64) + (local $v i64) + i32.const 1 + drop + i32.const 8 + i32.const 1 + i32.eq + drop + i32.const 8 + i32.const 2 + i32.eq + drop + i32.const 8 + i32.const 4 + i32.eq + drop + i32.const 8 + i32.const 8 + i32.eq + drop + local.get $value + i64.const 8 + i64.shr_u + i64.const 71777214294589695 + i64.and + local.set $a + local.get $value + i64.const 71777214294589695 + i64.and + i64.const 8 + i64.shl + local.set $b + local.get $a + local.get $b + i64.or + local.set $v + local.get $v + i64.const 16 + i64.shr_u + i64.const 281470681808895 + i64.and + local.set $a + local.get $v + i64.const 281470681808895 + i64.and + i64.const 16 + i64.shl + local.set $b + local.get $a + local.get $b + i64.or + i64.const 32 + i64.rotr + return + ) + (func $assembly/registers/newRegisters (result i32) + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + return + ) + (func $"~lib/map/Map#set:buckets" (param $this i32) (param $buckets i32) + local.get $this + local.get $buckets + i32.store + local.get $this + local.get $buckets + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $"~lib/map/Map#set:bucketsMask" (param $this i32) (param $bucketsMask i32) + local.get $this + local.get $bucketsMask + i32.store offset=4 + ) + (func $"~lib/map/Map#set:entries" (param $this i32) (param $entries i32) + local.get $this + local.get $entries + i32.store offset=8 + local.get $this + local.get $entries + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $"~lib/map/Map#set:entriesCapacity" (param $this i32) (param $entriesCapacity i32) + local.get $this + local.get $entriesCapacity + i32.store offset=12 + ) + (func $"~lib/map/Map#set:entriesOffset" (param $this i32) (param $entriesOffset i32) + local.get $this + local.get $entriesOffset + i32.store offset=16 + ) + (func $"~lib/map/Map#set:entriesCount" (param $this i32) (param $entriesCount i32) + local.get $this + local.get $entriesCount + i32.store offset=20 + ) + (func $assembly/memory/MemoryBuilder#set:pages (param $this i32) (param $pages i32) + local.get $this + local.get $pages + i32.store + local.get $this + local.get $pages + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory-page/Arena#set:arenaBytes (param $this i32) (param $arenaBytes i32) + local.get $this + local.get $arenaBytes + i32.store offset=4 + ) + (func $~lib/rt/__newBuffer (param $size i32) (param $id i32) (param $data i32) (result i32) + (local $buffer i32) + local.get $size + local.get $id + call $~lib/rt/itcms/__new + local.set $buffer + local.get $data + if + local.get $buffer + local.get $data + local.get $size + memory.copy + end + local.get $buffer + return + ) + (func $assembly/memory-page/Arena#set:free (param $this i32) (param $free i32) + local.get $this + local.get $free + i32.store + local.get $this + local.get $free + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory-page/Arena#set:extraPageIndex (param $this i32) (param $extraPageIndex i32) + local.get $this + local.get $extraPageIndex + i32.store offset=8 + ) + (func $assembly/memory-page/Arena#get:arenaBytes (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Arena#get:free (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/arraybuffer/ArrayBuffer#get:byteLength (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + return + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/rt/itcms/Object#get:rtSize (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $~lib/rt/itcms/__renew (param $oldPtr i32) (param $size i32) (result i32) + (local $oldObj i32) + (local $newPtr i32) + (local $4 i32) + (local $5 i32) + local.get $oldPtr + i32.const 20 + i32.sub + local.set $oldObj + local.get $size + local.get $oldObj + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.sub + i32.le_u + if + local.get $oldObj + local.get $size + call $~lib/rt/itcms/Object#set:rtSize + local.get $oldPtr + return + end + local.get $size + local.get $oldObj + call $~lib/rt/itcms/Object#get:rtId + call $~lib/rt/itcms/__new + local.set $newPtr + local.get $newPtr + local.get $oldPtr + local.get $size + local.tee $4 + local.get $oldObj + call $~lib/rt/itcms/Object#get:rtSize + local.tee $5 + local.get $4 + local.get $5 + i32.lt_u + select + memory.copy + local.get $newPtr + return + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $assembly/memory/MemoryBuilder#set:arena (param $this i32) (param $arena i32) + local.get $this + local.get $arena + i32.store offset=4 + local.get $this + local.get $arena + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/util/hash/HASH (param $key i32) (result i32) + (local $key|1 i32) + (local $len i32) + (local $h i32) + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 4 + i32.const 4 + i32.le_u + drop + block $~lib/util/hash/hash32|inlined.0 (result i32) + local.get $key + local.set $key|1 + i32.const 4 + local.set $len + i32.const 0 + i32.const 374761393 + i32.add + local.get $len + i32.add + local.set $h + local.get $h + local.get $key|1 + i32.const -1028477379 + i32.mul + i32.add + local.set $h + local.get $h + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 15 + i32.shr_u + i32.xor + local.set $h + local.get $h + i32.const -2048144777 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 13 + i32.shr_u + i32.xor + local.set $h + local.get $h + i32.const -1028477379 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 16 + i32.shr_u + i32.xor + local.set $h + local.get $h + br $~lib/util/hash/hash32|inlined.0 + end + return + ) + (func $"~lib/map/Map#get:buckets" (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $"~lib/map/Map#get:bucketsMask" (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $"~lib/map/MapEntry#get:taggedNext" (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#get:key" (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/Memory#set:lastAllocatedPage (param $this i32) (param $lastAllocatedPage i32) + local.get $this + local.get $lastAllocatedPage + i32.store + ) + (func $assembly/memory/Memory#set:arena (param $this i32) (param $arena i32) + local.get $this + local.get $arena + i32.store offset=4 + local.get $this + local.get $arena + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Memory#set:pages (param $this i32) (param $pages i32) + local.get $this + local.get $pages + i32.store offset=8 + local.get $this + local.get $pages + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Memory#set:sbrkAddress (param $this i32) (param $sbrkAddress i32) + local.get $this + local.get $sbrkAddress + i32.store offset=12 + ) + (func $assembly/memory/MemoryBuilder#get:arena (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/MemoryBuilder#get:pages (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/test/Assert#set:isOkay (param $this i32) (param $isOkay i32) + local.get $this + local.get $isOkay + i32.store8 + ) + (func $assembly/test/Assert#set:errors (param $this i32) (param $errors i32) + local.get $this + local.get $errors + i32.store offset=4 + local.get $this + local.get $errors + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/instructions/outcome/OutcomeData#get:outcome (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/util/number/decimalCount32 (param $value i32) (result i32) + local.get $value + i32.const 100000 + i32.lt_u + if + local.get $value + i32.const 100 + i32.lt_u + if + i32.const 1 + local.get $value + i32.const 10 + i32.ge_u + i32.add + return + else + i32.const 3 + local.get $value + i32.const 10000 + i32.ge_u + i32.add + local.get $value + i32.const 1000 + i32.ge_u + i32.add + return + end + unreachable + else + local.get $value + i32.const 10000000 + i32.lt_u + if + i32.const 6 + local.get $value + i32.const 1000000 + i32.ge_u + i32.add + return + else + i32.const 8 + local.get $value + i32.const 1000000000 + i32.ge_u + i32.add + local.get $value + i32.const 100000000 + i32.ge_u + i32.add + return + end + unreachable + end + unreachable + ) + (func $~lib/util/number/utoa32_dec_lut (param $buffer i32) (param $num i32) (param $offset i32) + (local $t i32) + (local $r i32) + (local $d1 i32) + (local $d2 i32) + (local $digits1 i64) + (local $digits2 i64) + (local $t|9 i32) + (local $d1|10 i32) + (local $digits i32) + (local $digits|12 i32) + (local $digit i32) + loop $while-continue|0 + local.get $num + i32.const 10000 + i32.ge_u + if + local.get $num + i32.const 10000 + i32.div_u + local.set $t + local.get $num + i32.const 10000 + i32.rem_u + local.set $r + local.get $t + local.set $num + local.get $r + i32.const 100 + i32.div_u + local.set $d1 + local.get $r + i32.const 100 + i32.rem_u + local.set $d2 + i32.const 2508 + local.get $d1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 2508 + local.get $d2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $num + i32.const 100 + i32.ge_u + if + local.get $num + i32.const 100 + i32.div_u + local.set $t|9 + local.get $num + i32.const 100 + i32.rem_u + local.set $d1|10 + local.get $t|9 + local.set $num + local.get $offset + i32.const 2 + i32.sub + local.set $offset + i32.const 2508 + local.get $d1|10 + i32.const 2 + i32.shl + i32.add + i32.load + local.set $digits + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits + i32.store + end + local.get $num + i32.const 10 + i32.ge_u + if + local.get $offset + i32.const 2 + i32.sub + local.set $offset + i32.const 2508 + local.get $num + i32.const 2 + i32.shl + i32.add + i32.load + local.set $digits|12 + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits|12 + i32.store + else + local.get $offset + i32.const 1 + i32.sub + local.set $offset + i32.const 48 + local.get $num + i32.add + local.set $digit + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digit + i32.store16 + end + ) + (func $~lib/util/number/utoa_hex_lut (param $buffer i32) (param $num i64) (param $offset i32) + loop $while-continue|0 + local.get $offset + i32.const 2 + i32.ge_u + if + local.get $offset + i32.const 2 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 2928 + local.get $num + i32.wrap_i64 + i32.const 255 + i32.and + i32.const 2 + i32.shl + i32.add + i32.load + i32.store + local.get $num + i64.const 8 + i64.shr_u + local.set $num + br $while-continue|0 + end + end + local.get $offset + i32.const 1 + i32.and + if + local.get $buffer + i32.const 2928 + local.get $num + i32.wrap_i64 + i32.const 6 + i32.shl + i32.add + i32.load16_u + i32.store16 + end + ) + (func $~lib/util/number/ulog_base (param $num i64) (param $base i32) (result i32) + (local $value i32) + (local $b64 i64) + (local $b i64) + (local $e i32) + block $~lib/util/number/isPowerOf2|inlined.0 (result i32) + local.get $base + local.set $value + local.get $value + i32.popcnt + i32.const 1 + i32.eq + br $~lib/util/number/isPowerOf2|inlined.0 + end + if + i32.const 63 + local.get $num + i64.clz + i32.wrap_i64 + i32.sub + i32.const 31 + local.get $base + i32.clz + i32.sub + i32.div_u + i32.const 1 + i32.add + return + end + local.get $base + i64.extend_i32_s + local.set $b64 + local.get $b64 + local.set $b + i32.const 1 + local.set $e + loop $while-continue|0 + local.get $num + local.get $b + i64.ge_u + if + local.get $num + local.get $b + i64.div_u + local.set $num + local.get $b + local.get $b + i64.mul + local.set $b + local.get $e + i32.const 1 + i32.shl + local.set $e + br $while-continue|0 + end + end + loop $while-continue|1 + local.get $num + i64.const 1 + i64.ge_u + if + local.get $num + local.get $b64 + i64.div_u + local.set $num + local.get $e + i32.const 1 + i32.add + local.set $e + br $while-continue|1 + end + end + local.get $e + i32.const 1 + i32.sub + return + ) + (func $~lib/util/number/utoa64_any_core (param $buffer i32) (param $num i64) (param $offset i32) (param $radix i32) + (local $base i64) + (local $shift i64) + (local $mask i64) + (local $q i64) + local.get $radix + i64.extend_i32_s + local.set $base + local.get $radix + local.get $radix + i32.const 1 + i32.sub + i32.and + i32.const 0 + i32.eq + if + local.get $radix + i32.ctz + i32.const 7 + i32.and + i64.extend_i32_s + local.set $shift + local.get $base + i64.const 1 + i64.sub + local.set $mask + loop $do-loop|0 + local.get $offset + i32.const 1 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 3984 + local.get $num + local.get $mask + i64.and + i32.wrap_i64 + i32.const 1 + i32.shl + i32.add + i32.load16_u + i32.store16 + local.get $num + local.get $shift + i64.shr_u + local.set $num + local.get $num + i64.const 0 + i64.ne + br_if $do-loop|0 + end + else + loop $do-loop|1 + local.get $offset + i32.const 1 + i32.sub + local.set $offset + local.get $num + local.get $base + i64.div_u + local.set $q + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 3984 + local.get $num + local.get $q + local.get $base + i64.mul + i64.sub + i32.wrap_i64 + i32.const 1 + i32.shl + i32.add + i32.load16_u + i32.store16 + local.get $q + local.set $num + local.get $num + i64.const 0 + i64.ne + br_if $do-loop|1 + end + end + ) + (func $~lib/number/I32#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/itoa32 + return + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/string/String#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 1 + i32.shr_u + return + ) + (func $assembly/test/Assert#get:errors (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array<~lib/string/String>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array<~lib/string/String>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array<~lib/string/String>#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/util/number/decimalCount64High (param $value i64) (result i32) + local.get $value + i64.const 1000000000000000 + i64.lt_u + if + local.get $value + i64.const 1000000000000 + i64.lt_u + if + i32.const 10 + local.get $value + i64.const 100000000000 + i64.ge_u + i32.add + local.get $value + i64.const 10000000000 + i64.ge_u + i32.add + return + else + i32.const 13 + local.get $value + i64.const 100000000000000 + i64.ge_u + i32.add + local.get $value + i64.const 10000000000000 + i64.ge_u + i32.add + return + end + unreachable + else + local.get $value + i64.const 100000000000000000 + i64.lt_u + if + i32.const 16 + local.get $value + i64.const 10000000000000000 + i64.ge_u + i32.add + return + else + i32.const 18 + local.get $value + i64.const -8446744073709551616 + i64.ge_u + i32.add + local.get $value + i64.const 1000000000000000000 + i64.ge_u + i32.add + return + end + unreachable + end + unreachable + ) + (func $~lib/util/number/utoa64_dec_lut (param $buffer i32) (param $num i64) (param $offset i32) + (local $t i64) + (local $r i32) + (local $b i32) + (local $c i32) + (local $b1 i32) + (local $b2 i32) + (local $c1 i32) + (local $c2 i32) + (local $digits1 i64) + (local $digits2 i64) + loop $while-continue|0 + local.get $num + i64.const 100000000 + i64.ge_u + if + local.get $num + i64.const 100000000 + i64.div_u + local.set $t + local.get $num + local.get $t + i64.const 100000000 + i64.mul + i64.sub + i32.wrap_i64 + local.set $r + local.get $t + local.set $num + local.get $r + i32.const 10000 + i32.div_u + local.set $b + local.get $r + i32.const 10000 + i32.rem_u + local.set $c + local.get $b + i32.const 100 + i32.div_u + local.set $b1 + local.get $b + i32.const 100 + i32.rem_u + local.set $b2 + local.get $c + i32.const 100 + i32.div_u + local.set $c1 + local.get $c + i32.const 100 + i32.rem_u + local.set $c2 + i32.const 2508 + local.get $c1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 2508 + local.get $c2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + i32.const 2508 + local.get $b1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 2508 + local.get $b2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $buffer + local.get $num + i32.wrap_i64 + local.get $offset + call $~lib/util/number/utoa32_dec_lut + ) + (func $~lib/number/U64#toString (param $this i64) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/utoa64 + return + ) + (func $assembly/test/Test#set:name (param $this i32) (param $name i32) + local.get $this + local.get $name + i32.store + local.get $this + local.get $name + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/test/Test#set:ptr (param $this i32) (param $ptr i32) + local.get $this + local.get $ptr + i32.store offset=4 + local.get $this + local.get $ptr + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/number/I64#toString (param $this i64) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/itoa64 + return + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/utils/u32SignExtend (param $v i32) (result i64) + local.get $v + i64.extend_i32_s + return + ) + (func $assembly/arguments/Args#get:c (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#get:staticJump (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/number/U32#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/utoa32 + return + ) + (func $~lib/math/ipow64 (param $x i64) (param $e i64) (result i64) + (local $out i64) + (local $log i32) + (local $4 i32) + i64.const 1 + local.set $out + i32.const 0 + i32.const 1 + i32.lt_s + drop + local.get $x + i64.const 2 + i64.eq + if + i64.const 1 + local.get $e + i64.shl + i64.const 0 + local.get $e + i64.const 64 + i64.lt_u + select + return + end + local.get $e + i64.const 0 + i64.le_s + if + local.get $x + i64.const -1 + i64.eq + if + i64.const -1 + i64.const 1 + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + select + return + end + local.get $e + i64.const 0 + i64.eq + i64.extend_i32_u + local.get $x + i64.const 1 + i64.eq + i64.extend_i32_u + i64.or + return + else + local.get $e + i64.const 1 + i64.eq + if + local.get $x + return + else + local.get $e + i64.const 2 + i64.eq + if + local.get $x + local.get $x + i64.mul + return + else + local.get $e + i64.const 64 + i64.lt_s + if + i32.const 64 + local.get $e + i64.clz + i32.wrap_i64 + i32.sub + local.set $log + block $break|0 + block $case5|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $log + local.set $4 + local.get $4 + i32.const 6 + i32.eq + br_if $case0|0 + local.get $4 + i32.const 5 + i32.eq + br_if $case1|0 + local.get $4 + i32.const 4 + i32.eq + br_if $case2|0 + local.get $4 + i32.const 3 + i32.eq + br_if $case3|0 + local.get $4 + i32.const 2 + i32.eq + br_if $case4|0 + local.get $4 + i32.const 1 + i32.eq + br_if $case5|0 + br $break|0 + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + end + local.get $out + return + end + end + end + end + loop $while-continue|1 + local.get $e + i64.const 0 + i64.ne + if + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + br $while-continue|1 + end + end + local.get $out + return + ) + (func $assembly/instructions/utils/mulUpperUnsigned (param $a i64) (param $b i64) (result i64) + (local $aHigh i64) + (local $aLow i64) + (local $bHigh i64) + (local $bLow i64) + (local $lowLow i64) + (local $lowHigh i64) + (local $highLow i64) + (local $highHigh i64) + (local $carry i64) + local.get $a + i64.const 32 + i64.shr_u + local.set $aHigh + local.get $a + i64.const 4294967295 + i64.and + local.set $aLow + local.get $b + i64.const 32 + i64.shr_u + local.set $bHigh + local.get $b + i64.const 4294967295 + i64.and + local.set $bLow + local.get $aLow + local.get $bLow + i64.mul + local.set $lowLow + local.get $aLow + local.get $bHigh + i64.mul + local.set $lowHigh + local.get $aHigh + local.get $bLow + i64.mul + local.set $highLow + local.get $aHigh + local.get $bHigh + i64.mul + local.set $highHigh + local.get $lowLow + i64.const 32 + i64.shr_u + local.get $lowHigh + i64.const 4294967295 + i64.and + i64.add + local.get $highLow + i64.const 4294967295 + i64.and + i64.add + local.set $carry + local.get $highHigh + local.get $lowHigh + i64.const 32 + i64.shr_u + i64.add + local.get $highLow + i64.const 32 + i64.shr_u + i64.add + local.get $carry + i64.const 32 + i64.shr_u + i64.add + return + ) + (func $assembly/instructions/utils/mulUpperSigned (param $a i64) (param $b i64) (result i64) + (local $isResultNegative i32) + (local $aAbs i64) + (local $bAbs i64) + (local $upper i64) + (local $lower i64) + i32.const 0 + local.set $isResultNegative + local.get $a + local.set $aAbs + local.get $b + local.set $bAbs + local.get $a + i64.const 0 + i64.lt_s + if + local.get $isResultNegative + i32.eqz + local.set $isResultNegative + local.get $a + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $aAbs + end + local.get $b + i64.const 0 + i64.lt_s + if + local.get $isResultNegative + i32.eqz + local.set $isResultNegative + local.get $b + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $bAbs + end + local.get $isResultNegative + if + local.get $aAbs + local.get $bAbs + call $assembly/instructions/utils/mulUpperUnsigned + local.set $upper + local.get $aAbs + local.get $bAbs + i64.mul + local.set $lower + local.get $upper + i64.const -1 + i64.xor + local.get $lower + i64.const 0 + i64.eq + if (result i64) + i64.const 1 + else + i64.const 0 + end + i64.add + return + end + local.get $aAbs + local.get $bAbs + call $assembly/instructions/utils/mulUpperUnsigned + return + ) + (func $assembly/instructions/utils/mulUpperSignedUnsigned (param $a i64) (param $b i64) (result i64) + (local $aAbs i64) + (local $upper i64) + (local $lower i64) + local.get $a + i64.const 0 + i64.lt_s + if + local.get $a + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $aAbs + local.get $aAbs + local.get $b + call $assembly/instructions/utils/mulUpperUnsigned + local.set $upper + local.get $aAbs + local.get $b + i64.mul + local.set $lower + local.get $upper + i64.const -1 + i64.xor + local.get $lower + i64.const 0 + i64.eq + if (result i64) + i64.const 1 + else + i64.const 0 + end + i64.add + return + end + local.get $a + local.get $b + call $assembly/instructions/utils/mulUpperUnsigned + return + ) + (func $assembly/instructions/rot/math.rot_r (param $v i64) (param $shift i64) (result i64) + local.get $v + local.get $shift + i64.rotr + return + ) + (func $assembly/instructions/rot/math.rot_r_32 (param $v i32) (param $shift i32) (result i32) + local.get $v + local.get $shift + i32.rotr + return + ) + (func $assembly/instructions/rot/math.rot_l (param $v i64) (param $shift i64) (result i64) + local.get $v + local.get $shift + i64.rotl + return + ) + (func $assembly/instructions/rot/math.rot_l_32 (param $v i32) (param $shift i32) (result i32) + local.get $v + local.get $shift + i32.rotl + return + ) + (func $assembly/memory/Chunks#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#set:first (param $this i32) (param $first i32) + local.get $this + local.get $first + i32.store offset=4 + local.get $this + local.get $first + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#set:second (param $this i32) (param $second i32) + local.get $this + local.get $second + i32.store offset=8 + local.get $this + local.get $second + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Memory#get:pages (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/memory/PageData#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/PageData#set:page (param $this i32) (param $page i32) + local.get $this + local.get $page + i32.store offset=4 + local.get $this + local.get $page + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/PageData#set:relativeAddress (param $this i32) (param $relativeAddress i32) + local.get $this + local.get $relativeAddress + i32.store offset=8 + ) + (func $"~lib/map/MapEntry#get:value" (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Page#get:access (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/PageData#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/MaybePageFault#get:isFault (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/memory/PageData#get:page (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/PageData#get:relativeAddress (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/memory-page/Page#get:raw (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/RawPage#get:page (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i32) (param $start i32) (param $end i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + local.get $start + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $start + i32.add + local.tee $5 + i32.const 0 + local.tee $6 + local.get $5 + local.get $6 + i32.gt_u + select + else + local.get $start + local.tee $7 + local.get $len + local.tee $8 + local.get $7 + local.get $8 + i32.lt_s + select + end + local.set $start + local.get $end + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $end + i32.add + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_u + select + else + local.get $end + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + end + local.set $end + i32.const 1 + i32.const 1 + i32.eq + drop + local.get $start + local.get $end + i32.lt_s + if + local.get $ptr + local.get $start + i32.add + local.get $value + local.get $end + local.get $start + i32.sub + memory.fill + end + ) + (func $assembly/memory/Chunks#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/ChunkBytes#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/ChunkBytes#set:bytes (param $this i32) (param $bytes i32) + local.get $this + local.get $bytes + i32.store offset=4 + local.get $this + local.get $bytes + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#get:first (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/Chunks#get:second (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 0 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + i32.const 0 + drop + ) + (func $assembly/memory/Result#set:ok (param $this i32) (param $ok i64) + local.get $this + local.get $ok + i64.store + ) + (func $assembly/memory/Result#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store offset=8 + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/ChunkBytes#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/ChunkBytes#get:bytes (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/Result#get:ok (param $this i32) (result i64) + local.get $this + i64.load + ) + (func $assembly/memory/Result#get:fault (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/number/Bool#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + if (result i32) + i32.const 9040 + else + i32.const 9072 + end + return + ) + (func $assembly/memory/MaybePageFault#get:isAccess (param $this i32) (result i32) + local.get $this + i32.load8_u offset=1 + ) + (func $assembly/memory/MaybePageFault#get:fault (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Arena#get:extraPageIndex (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#set:value" (param $this i32) (param $value i32) + local.get $this + local.get $value + i32.store offset=4 + ) + (func $"~lib/map/Map#get:entriesOffset" (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $"~lib/map/Map#get:entriesCapacity" (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $"~lib/map/Map#get:entriesCount" (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $"~lib/map/Map#get:entries" (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#set:key" (param $this i32) (param $key i32) + local.get $this + local.get $key + i32.store + ) + (func $"~lib/map/MapEntry#set:taggedNext" (param $this i32) (param $taggedNext i32) + local.get $this + local.get $taggedNext + i32.store offset=8 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i32) (result i32) + (local $sign i32) + (local $dest i32) + (local $decimals i32) + (local $val32 i32) + (local $buffer|6 i32) + (local $num i32) + (local $offset i32) + i32.const 0 + local.set $sign + i32.const 0 + drop + local.get $buffer + local.get $sign + i32.const 1 + i32.shl + i32.add + local.set $dest + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 0 + drop + local.get $value + i32.const 255 + i32.and + i32.const 10 + i32.lt_u + if + local.get $buffer + local.get $value + i32.const 255 + i32.and + i32.const 48 + i32.or + i32.store16 + i32.const 1 + return + end + i32.const 0 + local.set $decimals + i32.const 1 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 255 + i32.and + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + local.get $dest + local.set $buffer|6 + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|6 + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + local.get $sign + local.get $decimals + i32.add + return + ) + (func $~lib/util/string/compareImpl (param $str1 i32) (param $index1 i32) (param $str2 i32) (param $index2 i32) (param $len i32) (result i32) + (local $ptr1 i32) + (local $ptr2 i32) + (local $7 i32) + (local $a i32) + (local $b i32) + local.get $str1 + local.get $index1 + i32.const 1 + i32.shl + i32.add + local.set $ptr1 + local.get $str2 + local.get $index2 + i32.const 1 + i32.shl + i32.add + local.set $ptr2 + i32.const 0 + i32.const 2 + i32.lt_s + drop + local.get $len + i32.const 4 + i32.ge_u + if (result i32) + local.get $ptr1 + i32.const 7 + i32.and + local.get $ptr2 + i32.const 7 + i32.and + i32.or + i32.eqz + else + i32.const 0 + end + if + block $do-break|0 + loop $do-loop|0 + local.get $ptr1 + i64.load + local.get $ptr2 + i64.load + i64.ne + if + br $do-break|0 + end + local.get $ptr1 + i32.const 8 + i32.add + local.set $ptr1 + local.get $ptr2 + i32.const 8 + i32.add + local.set $ptr2 + local.get $len + i32.const 4 + i32.sub + local.set $len + local.get $len + i32.const 4 + i32.ge_u + br_if $do-loop|0 + end + end + end + loop $while-continue|1 + local.get $len + local.tee $7 + i32.const 1 + i32.sub + local.set $len + local.get $7 + if + local.get $ptr1 + i32.load16_u + local.set $a + local.get $ptr2 + i32.load16_u + local.set $b + local.get $a + local.get $b + i32.ne + if + local.get $a + local.get $b + i32.sub + return + end + local.get $ptr1 + i32.const 2 + i32.add + local.set $ptr1 + local.get $ptr2 + i32.const 2 + i32.add + local.set $ptr2 + br $while-continue|1 + end + end + i32.const 0 + return + ) + (func $assembly/arguments/Args#get:d (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/instructions/outcome/panic (result i32) + global.get $assembly/instructions/outcome/Result.PANIC + call $assembly/instructions/outcome/status + return + ) + (func $start:assembly/instructions/misc~anonymous|0 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/panic + ) + (func $start:assembly/instructions/misc~anonymous|1 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/panic + ) + (func $start:assembly/instructions/misc~anonymous|2 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/ok + ) + (func $assembly/memory/Memory#get:sbrkAddress (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/memory/Memory#get:lastAllocatedPage (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/Memory#get:arena (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/Instruction#set:namePtr (param $this i32) (param $namePtr i32) + local.get $this + local.get $namePtr + i32.store + ) + (func $assembly/instructions/Instruction#set:kind (param $this i32) (param $kind i32) + local.get $this + local.get $kind + i32.store offset=4 + ) + (func $assembly/instructions/Instruction#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=8 + ) + (func $assembly/instructions/Instruction#set:isTerminating (param $this i32) (param $isTerminating i32) + local.get $this + local.get $isTerminating + i32.store8 offset=16 + ) + (func $assembly/instructions/Instruction#constructor (param $this i32) (result i32) + local.get $this + i32.eqz + if + i32.const 17 + call $~lib/rt/tlsf/__alloc + local.set $this + end + local.get $this + i32.const 0 + call $assembly/instructions/Instruction#set:namePtr + local.get $this + global.get $assembly/arguments/Arguments.Zero + call $assembly/instructions/Instruction#set:kind + local.get $this + i64.const 0 + call $assembly/instructions/Instruction#set:gas + local.get $this + i32.const 0 + call $assembly/instructions/Instruction#set:isTerminating + local.get $this + ) + (func $assembly/instructions/instruction (param $name i32) (param $kind i32) (param $gas i64) (param $isTerminating i32) (result i32) + (local $i i32) + i32.const 0 + call $assembly/instructions/Instruction#constructor + local.set $i + local.get $i + local.get $name + call $assembly/instructions/Instruction#set:namePtr + local.get $i + local.get $kind + call $assembly/instructions/Instruction#set:kind + local.get $i + local.get $gas + call $assembly/instructions/Instruction#set:gas + local.get $i + local.get $isTerminating + call $assembly/instructions/Instruction#set:isTerminating + local.get $i + return + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $start:assembly/program + call $start:assembly/instructions + ) + (func $assembly/program/Mask#set:bytesToSkip (param $this i32) (param $bytesToSkip i32) + local.get $this + local.get $bytesToSkip + i32.store + local.get $this + local.get $bytesToSkip + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Mask#get:bytesToSkip (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i32) (result i32) + (local $sign i32) + (local $dest i32) + (local $decimals i32) + (local $val32 i32) + (local $buffer|6 i32) + (local $num i32) + (local $offset i32) + i32.const 0 + local.set $sign + i32.const 0 + drop + local.get $buffer + local.get $sign + i32.const 1 + i32.shl + i32.add + local.set $dest + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 0 + drop + local.get $value + i32.const 10 + i32.lt_u + if + local.get $buffer + local.get $value + i32.const 48 + i32.or + i32.store16 + i32.const 1 + return + end + i32.const 0 + local.set $decimals + i32.const 4 + i32.const 4 + i32.le_u + drop + local.get $value + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + local.get $dest + local.set $buffer|6 + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|6 + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + local.get $sign + local.get $decimals + i32.add + return + ) + (func $~lib/string/String#toString (param $this i32) (result i32) + local.get $this + return + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/codec/Decoder#set:source (param $this i32) (param $source i32) + local.get $this + local.get $source + i32.store + local.get $this + local.get $source + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/codec/Decoder#set:offset (param $this i32) (param $offset i32) + local.get $this + local.get $offset + i32.store offset=4 + ) + (func $assembly/codec/Decoder#get:offset (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/codec/Decoder#get:source (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/codec/ValOffset#set:value (param $this i32) (param $value i32) + local.get $this + local.get $value + i32.store + ) + (func $assembly/codec/ValOffset#set:offset (param $this i32) (param $offset i32) + local.get $this + local.get $offset + i32.store offset=4 + ) + (func $assembly/codec/ValOffset#get:offset (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/codec/ValOffset#get:value (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/JumpTable#set:jumps (param $this i32) (param $jumps i32) + local.get $this + local.get $jumps + i32.store + local.get $this + local.get $jumps + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + ) + (func $assembly/instructions/Instruction#get:isTerminating (param $this i32) (result i32) + local.get $this + i32.load8_u offset=16 + ) + (func $assembly/program/BasicBlocks#set:isStartOrEnd (param $this i32) (param $isStartOrEnd i32) + local.get $this + local.get $isStartOrEnd + i32.store + local.get $this + local.get $isStartOrEnd + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:code (param $this i32) (param $code i32) + local.get $this + local.get $code + i32.store + local.get $this + local.get $code + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:mask (param $this i32) (param $mask i32) + local.get $this + local.get $mask + i32.store offset=4 + local.get $this + local.get $mask + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:jumpTable (param $this i32) (param $jumpTable i32) + local.get $this + local.get $jumpTable + i32.store offset=8 + local.get $this + local.get $jumpTable + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:basicBlocks (param $this i32) (param $basicBlocks i32) + local.get $this + local.get $basicBlocks + i32.store offset=12 + local.get $this + local.get $basicBlocks + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#get:mask (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/program/Program#get:jumpTable (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/program/JumpTable#get:jumps (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/Program#get:basicBlocks (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/program/BasicBlocks#get:isStartOrEnd (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $start:assembly/spi + i32.const 2 + i32.const 24 + call $~lib/math/ipow32 + global.set $assembly/spi/DATA_LENGTH + i32.const 2 + i32.const 32 + call $~lib/math/ipow32 + global.get $assembly/memory-page/SEGMENT_SIZE + i32.sub + global.get $assembly/spi/DATA_LENGTH + i32.sub + global.set $assembly/spi/ARGS_SEGMENT_START + i32.const 2 + i32.const 32 + call $~lib/math/ipow32 + i32.const 2 + global.get $assembly/memory-page/SEGMENT_SIZE + i32.mul + i32.sub + global.get $assembly/spi/DATA_LENGTH + i32.sub + global.set $assembly/spi/STACK_SEGMENT_END + ) + (func $assembly/spi/alignToSegmentSize (param $size i32) (result i32) + local.get $size + global.get $assembly/memory-page/SEGMENT_SIZE + i32.add + i32.const 1 + i32.sub + global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT + i32.shr_u + global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT + i32.shl + return + ) + (func $assembly/spi/alignToPageSize (param $size i32) (result i32) + local.get $size + global.get $assembly/memory-page/PAGE_SIZE + i32.add + i32.const 1 + i32.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + return + ) + (func $assembly/spi/StandardProgram#set:program (param $this i32) (param $program i32) + local.get $this + local.get $program + i32.store offset=16 + local.get $this + local.get $program + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/spi/StandardProgram#set:memory (param $this i32) (param $memory i32) + local.get $this + local.get $memory + i32.store offset=20 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/spi/StandardProgram#set:registers (param $this i32) (param $registers i32) + local.get $this + local.get $registers + i32.store offset=24 + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/spi/StandardProgram#set:metadata (param $this i32) (param $metadata i32) + local.get $this + local.get $metadata + i32.store + local.get $this + local.get $metadata + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/spi/StandardProgram#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store offset=4 + ) + (func $assembly/spi/StandardProgram#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=8 + ) + (func $assembly/spi/StandardProgram#get:program (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/program/Program#get:code (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/spi/StandardProgram#get:memory (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $assembly/spi/StandardProgram#get:registers (param $this i32) (result i32) + local.get $this + i32.load offset=24 + ) + (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i64) (result i32) + (local $sign i32) + (local $dest i32) + (local $decimals i32) + (local $val32 i32) + (local $buffer|6 i32) + (local $num i32) + (local $offset i32) + (local $val64 i64) + (local $buffer|10 i32) + (local $num|11 i64) + (local $offset|12 i32) + i32.const 0 + local.set $sign + i32.const 0 + drop + local.get $buffer + local.get $sign + i32.const 1 + i32.shl + i32.add + local.set $dest + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 0 + drop + local.get $value + i64.const 10 + i64.lt_u + if + local.get $buffer + local.get $value + i32.const 48 + i64.extend_i32_s + i64.or + i64.store16 + i32.const 1 + return + end + i32.const 0 + local.set $decimals + i32.const 8 + i32.const 4 + i32.le_u + drop + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + local.get $dest + local.set $buffer|6 + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|6 + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + local.set $val64 + local.get $val64 + call $~lib/util/number/decimalCount64High + local.set $decimals + local.get $dest + local.set $buffer|10 + local.get $val64 + local.set $num|11 + local.get $decimals + local.set $offset|12 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|10 + local.get $num|11 + local.get $offset|12 + call $~lib/util/number/utoa64_dec_lut + end + local.get $sign + local.get $decimals + i32.add + return + ) + (func $start:assembly/test-run + call $start:assembly/instructions/bit.test + call $start:assembly/instructions/branch.test + call $start:assembly/instructions/logic.test + call $start:assembly/instructions/math.test + call $start:assembly/instructions/rot.test + call $start:assembly/memory.test + call $start:assembly/program.test + call $start:assembly/spi.test + ) + (func $assembly/test/Test#get:name (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/test/Test#get:ptr (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/test/Assert#get:isOkay (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $~lib/rt/__visit_globals (param $0 i32) + (local $1 i32) + i32.const 480 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 1296 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 9584 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 21616 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 8624 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 288 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 2928 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 3984 + local.get $0 + call $~lib/rt/itcms/__visit + global.get $assembly/instructions/bit.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/branch.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/logic.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/math.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/rot.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/program.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/spi.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/RELEVANT_ARGS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/REQUIRED_BYTES + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/DECODERS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_PAGE + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions-exe/RUN + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/codec/MASKS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/INSTRUCTIONS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + ) + (func $~lib/arraybuffer/ArrayBufferView~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/object/Object~visit (param $0 i32) (param $1 i32) + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/typedarray/Uint8Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit + ) + (func $assembly/memory-page/Page~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory-page/RawPage~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/Memory~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory-page/Arena~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $"~lib/map/Map~visit" (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $"~lib/map/Map#__visit" + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit + ) + (func $assembly/test/Test~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/test/Assert~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array<~lib/string/String>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<~lib/string/String>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/memory/MemoryBuilder~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + i32.const 1 + drop + local.get $this + local.set $cur + local.get $cur + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray<~lib/string/String>#__visit + ) + (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#__visit + ) + (func $assembly/memory/Result~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/ChunkBytes~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/Chunks~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/PageData~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/typedarray/Uint8ClampedArray~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/function/Function<%28u8%29=>u8>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28u8%29=>u8>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28u8%29=>u8>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/program/Mask~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/program/Program~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/JumpTable~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/BasicBlocks~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/codec/Decoder~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/spi/StandardProgram~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=16 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=20 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=24 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/rt/__visit_members (param $0 i32) (param $1 i32) + block $invalid + block $assembly/spi/StandardProgram + block $assembly/codec/ValOffset + block $assembly/codec/Decoder + block $~lib/staticarray/StaticArray + block $assembly/program/BasicBlocks + block $assembly/program/JumpTable + block $assembly/program/Program + block $~lib/array/Array + block $~lib/array/Array + block $~lib/staticarray/StaticArray + block $assembly/program/Mask + block $~lib/array/Array + block $~lib/function/Function<%28u8%29=>u8> + block $~lib/array/Array + block $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> + block $~lib/typedarray/Uint8ClampedArray + block $assembly/memory/PageData + block $assembly/memory/Chunks + block $~lib/staticarray/StaticArray + block $assembly/memory/ChunkBytes + block $assembly/memory/Result + block $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert> + block $~lib/staticarray/StaticArray<~lib/string/String> + block $assembly/memory/MemoryBuilder + block $~lib/array/Array + block $~lib/array/Array<~lib/string/String> + block $assembly/test/Assert + block $assembly/test/Test + block $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> + block $assembly/instructions/outcome/OutcomeData + block $"~lib/map/Map" + block $~lib/array/Array + block $assembly/memory-page/Arena + block $assembly/memory/Memory + block $~lib/staticarray/StaticArray + block $assembly/memory-page/RawPage + block $assembly/memory-page/Page + block $assembly/memory/MaybePageFault + block $assembly/arguments/Nibbles + block $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> + block $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> + block $assembly/arguments/Args + block $~lib/typedarray/Uint8Array + block $~lib/array/Array + block $~lib/arraybuffer/ArrayBufferView + block $~lib/string/String + block $~lib/arraybuffer/ArrayBuffer + block $~lib/object/Object + local.get $0 + i32.const 8 + i32.sub + i32.load + br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $~lib/arraybuffer/ArrayBufferView $~lib/array/Array $~lib/typedarray/Uint8Array $assembly/arguments/Args $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $assembly/arguments/Nibbles $assembly/memory/MaybePageFault $assembly/memory-page/Page $assembly/memory-page/RawPage $~lib/staticarray/StaticArray $assembly/memory/Memory $assembly/memory-page/Arena $~lib/array/Array $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $assembly/test/Test $assembly/test/Assert $~lib/array/Array<~lib/string/String> $~lib/array/Array $assembly/memory/MemoryBuilder $~lib/staticarray/StaticArray<~lib/string/String> $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert> $assembly/memory/Result $assembly/memory/ChunkBytes $~lib/staticarray/StaticArray $assembly/memory/Chunks $assembly/memory/PageData $~lib/typedarray/Uint8ClampedArray $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $~lib/array/Array $~lib/function/Function<%28u8%29=>u8> $~lib/array/Array $assembly/program/Mask $~lib/staticarray/StaticArray $~lib/array/Array $~lib/array/Array $assembly/program/Program $assembly/program/JumpTable $assembly/program/BasicBlocks $~lib/staticarray/StaticArray $assembly/codec/Decoder $assembly/codec/ValOffset $assembly/spi/StandardProgram $invalid + end + return + end + return + end + return + end + local.get $0 + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/typedarray/Uint8Array~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit + return + end + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/Page~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/RawPage~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory/Memory~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/Arena~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $"~lib/map/Map~visit" + return + end + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit + return + end + local.get $0 + local.get $1 + call $assembly/test/Test~visit + return + end + local.get $0 + local.get $1 + call $assembly/test/Assert~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<~lib/string/String>~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/MemoryBuilder~visit + return + end + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray<~lib/string/String>~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/Result~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/ChunkBytes~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory/Chunks~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/PageData~visit + return + end + local.get $0 + local.get $1 + call $~lib/typedarray/Uint8ClampedArray~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28u8%29=>u8>~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/Mask~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/Program~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/JumpTable~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/BasicBlocks~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/codec/Decoder~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/spi/StandardProgram~visit + return + end + unreachable + ) + (func $~start + call $start:assembly/test-run + ) + (func $~stack_check + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__data_end + i32.lt_s + if + i32.const 60848 + i32.const 60896 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + ) + (func $assembly/arguments/Args#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 6 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:b + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:c + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:d + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/arguments/Args.from (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32) + (local $x i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $x + i32.store + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $a + call $assembly/arguments/Args#set:a + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $b + call $assembly/arguments/Args#set:b + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $c + call $assembly/arguments/Args#set:c + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $d + call $assembly/arguments/Args#set:d + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/typedarray/Uint8Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/typedarray/Uint8Array#subarray (param $this i32) (param $begin i32) (param $end i32) (result i32) + (local $array i32) + (local $begin|4 i32) + (local $end|5 i32) + (local $len i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + (local $out i32) + (local $buf i32) + (local $19 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + block $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $array + i32.store + local.get $begin + local.set $begin|4 + local.get $end + local.set $end|5 + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + local.get $begin|4 + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $begin|4 + i32.add + local.tee $7 + i32.const 0 + local.tee $8 + local.get $7 + local.get $8 + i32.gt_s + select + else + local.get $begin|4 + local.tee $9 + local.get $len + local.tee $10 + local.get $9 + local.get $10 + i32.lt_s + select + end + local.set $begin|4 + local.get $end|5 + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $end|5 + i32.add + local.tee $11 + i32.const 0 + local.tee $12 + local.get $11 + local.get $12 + i32.gt_s + select + else + local.get $end|5 + local.tee $13 + local.get $len + local.tee $14 + local.get $13 + local.get $14 + i32.lt_s + select + end + local.set $end|5 + local.get $end|5 + local.tee $15 + local.get $begin|4 + local.tee $16 + local.get $15 + local.get $16 + i32.gt_s + select + local.set $end|5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=8 + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $buf + local.get $out + local.get $buf + i32.store + local.get $out + local.get $buf + i32.const 0 + call $~lib/rt/itcms/__link + local.get $out + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $begin|4 + i32.const 0 + i32.shl + i32.add + i32.store offset=4 + local.get $out + local.get $end|5 + local.get $begin|4 + i32.sub + i32.const 0 + i32.shl + i32.store offset=8 + local.get $out + br $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" + end + local.set $19 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $19 + return + ) + (func $~lib/typedarray/Uint8Array#__get (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + i32.ge_u + if + i32.const 480 + i32.const 720 + i32.const 167 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $index + i32.add + i32.load8_u + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/arguments/decodeI32 (param $input i32) (param $start i32) (param $end i32) (result i32) + (local $data i32) + (local $value1 f64) + (local $value2 f64) + (local $len i32) + (local $num i32) + (local $i i32) + (local $msb i32) + (local $prefix i32) + (local $i|11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $input + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $start + local.get $end + local.get $start + i32.gt_u + if (result i32) + local.get $end + else + local.get $start + end + call $~lib/typedarray/Uint8Array#subarray + local.tee $data + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.0 (result f64) + f64.const 4 + local.set $value1 + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.0 + end + i32.trunc_sat_f64_u + local.set $len + i32.const 0 + local.set $num + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_u + if + local.get $num + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.get $i + i32.const 8 + i32.mul + i32.shl + i32.or + local.set $num + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $len + i32.const 0 + i32.gt_u + if (result i32) + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $len + i32.const 1 + i32.sub + call $~lib/typedarray/Uint8Array#__get + i32.const 128 + i32.and + else + i32.const 0 + end + local.set $msb + local.get $msb + i32.const 0 + i32.gt_u + if (result i32) + i32.const 255 + else + i32.const 0 + end + local.set $prefix + local.get $len + local.set $i|11 + loop $for-loop|1 + local.get $i|11 + i32.const 4 + i32.lt_u + if + local.get $num + local.get $prefix + local.get $i|11 + i32.const 8 + i32.mul + i32.shl + i32.or + local.set $num + local.get $i|11 + i32.const 1 + i32.add + local.set $i|11 + br $for-loop|1 + end + end + local.get $num + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $start:assembly/arguments~anonymous|1 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/arguments/Nibbles#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 2 + i32.const 9 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Nibbles#set:low + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Nibbles#set:hig + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/arguments/nibbles (param $byte i32) (result i32) + (local $low i32) + (local $hig i32) + (local $n i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $byte + i32.const 15 + i32.and + local.set $low + local.get $byte + i32.const 255 + i32.and + i32.const 4 + i32.const 7 + i32.and + i32.shr_u + local.set $hig + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Nibbles#constructor + local.tee $n + i32.store + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $low + call $assembly/arguments/Nibbles#set:low + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $hig + call $assembly/arguments/Nibbles#set:hig + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/arguments/twoImm (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $first i32) + (local $second i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.1 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.1 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $first + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $second + local.get $first + local.get $second + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|2 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $lim + call $assembly/arguments/twoImm + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $start:assembly/arguments~anonymous|3 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/arguments~anonymous|4 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/typedarray/Uint8Array#subarray@varargs (param $this i32) (param $begin i32) (param $end i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $begin + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $begin + local.get $end + call $~lib/typedarray/Uint8Array#subarray + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/arguments/decodeU32 (param $data i32) (result i32) + (local $num i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 2 + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 3 + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + local.set $num + local.get $num + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/arguments~anonymous|5 (param $data i32) (param $_lim i32) (result i32) + (local $a i32) + (local $b i32) + (local $c i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Nibbles#get:low + local.set $a + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/decodeU32 + local.set $b + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 5 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/decodeU32 + local.set $c + local.get $a + i32.const 255 + i32.and + local.get $b + local.get $c + i32.const 0 + call $assembly/arguments/Args.from + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/arguments~anonymous|6 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $immA i32) + (local $immB i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.2 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.2 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $immA + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $immB + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $immA + local.get $immB + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|7 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $immA i32) + (local $offs i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.3 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.3 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $immA + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $offs + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $immA + local.get $offs + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|8 (param $data i32) (param $_lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|9 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|10 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|11 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + i32.const 1 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $lim + i32.const 1 + i32.gt_u + if (result i32) + local.get $lim + i32.const 1 + i32.sub + else + i32.const 0 + end + call $assembly/arguments/twoImm + local.tee $result + i32.store offset=12 + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:a + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/arguments/Args.from + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/arguments~anonymous|12 (param $data i32) (param $_lim i32) (result i32) + (local $a i32) + (local $b i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $a + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $b + i32.store offset=8 + local.get $a + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $a + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $b + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + i32.const 0 + call $assembly/arguments/Args.from + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/MaybePageFault#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 10 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:isFault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:isAccess + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:fault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/arraybuffer/ArrayBufferView#constructor (param $this i32) (param $length i32) (param $alignLog2 i32) (result i32) + (local $buffer i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 3 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:buffer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:byteLength + local.get $length + i32.const 1073741820 + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1344 + i32.const 19 + i32.const 57 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $length + local.get $alignLog2 + i32.shl + local.tee $length + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $buffer + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $~lib/arraybuffer/ArrayBufferView#set:buffer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $buffer + call $~lib/arraybuffer/ArrayBufferView#set:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $length + call $~lib/arraybuffer/ArrayBufferView#set:byteLength + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $length + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#constructor + local.tee $this + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/memory-page/Page#constructor (param $this i32) (param $access i32) (param $raw i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 11 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $access + call $assembly/memory-page/Page#set:access + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $raw + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory-page/Page#set:raw + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory-page/RawPage#constructor (param $this i32) (param $id i32) (param $page i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 12 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $id + call $assembly/memory-page/RawPage#set:id + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $page + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory-page/RawPage#set:page + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $start:assembly/memory + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + call $start:assembly/memory-page + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + global.set $assembly/memory/NO_PAGE_FAULT + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + global.set $assembly/memory/EMPTY_UINT8ARRAY + i32.const 0 + global.get $assembly/memory-page/Access.None + i32.const 0 + i32.const -1 + i32.const 0 + call $assembly/memory-page/RawPage#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/memory-page/Page#constructor + global.set $assembly/memory/EMPTY_PAGE + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i64) + (local $value i64) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/OutcomeData#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.const 18 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/instructions/outcome/Outcome.Ok + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:staticJump + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:dJump + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/instructions/outcome/Result.PANIC + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:exitCode + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/bit~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.popcnt + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.popcnt + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.clz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.clz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ctz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.ctz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u8SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u16SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|8 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.const 65535 + i32.and + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|9 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/polyfills/bswap + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $"~lib/map/Map#constructor" (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.const 17 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 4 + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + i32.const 1 + i32.sub + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 4 + block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.0" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesOffset" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/typedarray/Uint8Array.wrap (param $buffer i32) (param $byteOffset i32) (param $length i32) (result i32) + (local $buffer|3 i32) + (local $byteOffset|4 i32) + (local $len i32) + (local $byteLength i32) + (local $bufferByteLength i32) + (local $out i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + block $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) + global.get $~lib/memory/__stack_pointer + local.get $buffer + local.tee $buffer|3 + i32.store + local.get $byteOffset + local.set $byteOffset|4 + local.get $length + local.set $len + local.get $buffer|3 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/arraybuffer/ArrayBuffer#get:byteLength + local.set $bufferByteLength + local.get $byteOffset|4 + local.get $bufferByteLength + i32.gt_u + local.get $byteOffset|4 + i32.const 0 + i32.and + i32.or + if + i32.const 480 + i32.const 720 + i32.const 1860 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $len + i32.const 0 + i32.lt_s + if + local.get $len + i32.const -1 + i32.eq + if + local.get $bufferByteLength + i32.const 0 + i32.and + if + i32.const 1296 + i32.const 720 + i32.const 1865 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + local.get $bufferByteLength + local.get $byteOffset|4 + i32.sub + local.set $byteLength + else + i32.const 1296 + i32.const 720 + i32.const 1869 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + else + local.get $len + i32.const 0 + i32.shl + local.set $byteLength + local.get $byteOffset|4 + local.get $byteLength + i32.add + local.get $bufferByteLength + i32.gt_s + if + i32.const 1296 + i32.const 720 + i32.const 1874 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=8 + local.get $out + local.get $buffer|3 + i32.store + local.get $out + local.get $buffer|3 + i32.const 0 + call $~lib/rt/itcms/__link + local.get $out + local.get $byteLength + i32.store offset=8 + local.get $out + local.get $buffer|3 + local.get $byteOffset|4 + i32.add + i32.store offset=4 + local.get $out + br $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" + end + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $~lib/array/ensureCapacity (param $array i32) (param $newSize i32) (param $alignLog2 i32) (param $canGrow i32) + (local $oldCapacity i32) + (local $oldData i32) + (local $6 i32) + (local $7 i32) + (local $newCapacity i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $newData i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $array + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + local.set $oldCapacity + local.get $newSize + local.get $oldCapacity + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + local.get $newSize + i32.const 1073741820 + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1888 + i32.const 19 + i32.const 48 + call $~lib/builtins/abort + unreachable + end + local.get $array + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $oldData + local.get $newSize + local.tee $6 + i32.const 8 + local.tee $7 + local.get $6 + local.get $7 + i32.gt_u + select + local.get $alignLog2 + i32.shl + local.set $newCapacity + local.get $canGrow + if + local.get $oldCapacity + i32.const 1 + i32.shl + local.tee $9 + i32.const 1073741820 + local.tee $10 + local.get $9 + local.get $10 + i32.lt_u + select + local.tee $11 + local.get $newCapacity + local.tee $12 + local.get $11 + local.get $12 + i32.gt_u + select + local.set $newCapacity + end + local.get $oldData + local.get $newCapacity + call $~lib/rt/itcms/__renew + local.set $newData + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $newData + local.get $oldData + i32.ne + if + local.get $array + local.get $newData + i32.store + local.get $array + local.get $newData + i32.store offset=4 + local.get $array + local.get $newData + i32.const 0 + call $~lib/rt/itcms/__link + end + local.get $array + local.get $newCapacity + i32.store offset=8 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#unshift (param $this i32) (param $value i32) (result i32) + (local $len i32) + (local $ptr i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.set $ptr + local.get $ptr + i32.const 4 + i32.add + local.get $ptr + local.get $len + i32.const 1 + i32.sub + i32.const 2 + i32.shl + memory.copy + local.get $ptr + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory-page/Arena#constructor (param $this i32) (param $pageCount i32) (result i32) + (local $2 i32) + (local $data i32) + (local $i i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 15 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:free + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:arenaBytes + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:extraPageIndex + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/memory-page/PAGE_SIZE + local.get $pageCount + i32.mul + call $assembly/memory-page/Arena#set:arenaBytes + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + i32.const 2 + i32.const 16 + i32.const 1856 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory-page/Arena#set:free + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pageCount + call $assembly/memory-page/Arena#set:extraPageIndex + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory-page/Arena#get:arenaBytes + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $data + i32.store offset=12 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pageCount + i32.lt_s + if + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory-page/Arena#get:free + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + local.get $i + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array.wrap + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory-page/RawPage#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/array/Array#unshift + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/memory/MemoryBuilder#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 24 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#constructor" + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/MemoryBuilder#set:pages + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 128 + call $assembly/memory-page/Arena#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/MemoryBuilder#set:arena + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $"~lib/map/Map#find" (param $this i32) (param $key i32) (param $hashCode i32) (result i32) + (local $entry i32) + (local $taggedNext i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + i32.load + local.set $entry + loop $while-continue|0 + local.get $entry + if + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + local.set $taggedNext + local.get $taggedNext + i32.const 1 + i32.and + i32.eqz + if (result i32) + local.get $entry + call $"~lib/map/MapEntry#get:key" + local.get $key + i32.eq + else + i32.const 0 + end + if + local.get $entry + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $taggedNext + i32.const 1 + i32.const -1 + i32.xor + i32.and + local.set $entry + br $while-continue|0 + end + end + i32.const 0 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $"~lib/map/Map#has" (param $this i32) (param $key i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $key + local.get $key + call $~lib/util/hash/HASH + call $"~lib/map/Map#find" + i32.const 0 + i32.ne + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/Memory#constructor (param $this i32) (param $arena i32) (param $pages i32) (param $sbrkAddress i32) (result i32) + (local $sbrkPage i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 14 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $arena + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory/Memory#set:arena + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory/Memory#set:pages + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $sbrkAddress + call $assembly/memory/Memory#set:sbrkAddress + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $sbrkAddress + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $sbrkPage + local.get $sbrkPage + global.get $assembly/memory-page/RESERVED_PAGES + i32.lt_u + if + i32.const 1936 + i32.const 2048 + i32.const 119 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $sbrkPage + call $"~lib/map/Map#has" + if (result i32) + local.get $sbrkPage + else + local.get $sbrkPage + i32.const 1 + i32.sub + end + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/memory/MemoryBuilder#build (param $this i32) (param $sbrkAddress i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + i32.const 0 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MemoryBuilder#get:arena + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MemoryBuilder#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $sbrkAddress + call $assembly/memory/Memory#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/MemoryBuilder#build@varargs (param $this i32) (param $sbrkAddress i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + global.get $assembly/memory-page/RESERVED_MEMORY + local.set $sbrkAddress + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $sbrkAddress + call $assembly/memory/MemoryBuilder#build + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/test/Assert#constructor (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 21 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 1 + call $assembly/test/Assert#set:isOkay + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 2 + i32.const 22 + i32.const 2112 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/test/Assert#set:errors + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/util/string/joinStringArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $4 i32) + (local $estLen i32) + (local $value i32) + (local $i i32) + (local $offset i32) + (local $sepLen i32) + (local $result i32) + (local $i|11 i32) + (local $valueLen i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + end + local.get $lastIndex + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + i32.load + local.tee $4 + i32.store + local.get $4 + if (result i32) + local.get $4 + else + i32.const 4080 + end + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + end + i32.const 0 + local.set $estLen + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $i + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $estLen + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + i32.add + local.set $estLen + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $offset + local.get $separator + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + local.set $sepLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + local.get $sepLen + local.get $lastIndex + i32.mul + i32.add + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=12 + i32.const 0 + local.set $i|11 + loop $for-loop|1 + local.get $i|11 + local.get $lastIndex + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $i|11 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + local.set $valueLen + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value + local.get $valueLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $valueLen + i32.add + local.set $offset + end + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i|11 + i32.const 1 + i32.add + local.set $i|11 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $lastIndex + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + memory.copy + end + local.get $result + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + i32.const 1 + i32.lt_s + drop + i32.const 1 + drop + local.get $this + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/staticarray/StaticArray<~lib/string/String>#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/util/string/joinStringArray + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/array/Array<~lib/string/String>#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array<~lib/string/String>#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 1 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array<~lib/string/String>#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) + (local $4 i32) + (local $5 i32) + (local $actualDisplay i32) + (local $7 i32) + (local $8 i32) + (local $expectDisplay i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $actual + local.get $expected + i32.ne + if + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 10 + call $~lib/number/I32#toString + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 16 + call $~lib/number/I32#toString + local.tee $5 + i32.store offset=8 + i32.const 2256 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $4 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 2256 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $5 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 2256 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $actualDisplay + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 10 + call $~lib/number/I32#toString + local.tee $7 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 16 + call $~lib/number/I32#toString + local.tee $8 + i32.store offset=24 + i32.const 4112 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $7 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4112 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $8 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4112 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $expectDisplay + i32.store offset=28 + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + call $assembly/test/Assert#get:errors + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $10 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $12 + i32.store offset=44 + i32.const 4272 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 1 + local.get $10 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4272 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 3 + local.get $11 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4272 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 5 + local.get $12 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4272 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i64) (param $expected i64) (param $msg i32) + (local $4 i32) + (local $5 i32) + (local $actualDisplay i32) + (local $7 i32) + (local $8 i32) + (local $expectDisplay i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $actual + local.get $expected + i64.ne + if + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 10 + call $~lib/number/U64#toString + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 16 + call $~lib/number/U64#toString + local.tee $5 + i32.store offset=8 + i32.const 4320 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $4 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4320 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $5 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4320 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $actualDisplay + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 10 + call $~lib/number/U64#toString + local.tee $7 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 16 + call $~lib/number/U64#toString + local.tee $8 + i32.store offset=24 + i32.const 4368 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $7 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4368 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $8 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4368 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $expectDisplay + i32.store offset=28 + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + call $assembly/test/Assert#get:errors + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $10 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $12 + i32.store offset=44 + i32.const 4416 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 1 + local.get $10 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4416 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 3 + local.get $11 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4416 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 5 + local.get $12 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4416 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit.test~anonymous|0 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281470681747729 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/count_set_bits_64 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 2 + i64.const 8 + i64.mul + i64.const 4 + i64.add + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/test/Test#constructor (param $this i32) (param $name i32) (param $ptr i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 20 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $name + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/test/Test#set:name + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $ptr + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/test/Test#set:ptr + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/test/test (param $name i32) (param $ptr i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 0 + local.get $name + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $ptr + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/test/Test#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|1 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281470681747729 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/count_set_bits_32 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 4 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|2 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281406257234193 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/leading_zero_bits_64 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 16 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|3 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281470681747729 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/leading_zero_bits_32 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 19 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|4 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281406257233920 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/trailing_zero_bits_64 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 36 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|5 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281406257233920 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/trailing_zero_bits_32 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 32 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|6 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/sign_extend_8 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -17 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|7 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/sign_extend_16 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -16657 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|8 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/zero_extend_16 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 48879 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i64) (param $expected i64) (param $msg i32) + (local $4 i32) + (local $5 i32) + (local $actualDisplay i32) + (local $7 i32) + (local $8 i32) + (local $expectDisplay i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $actual + local.get $expected + i64.ne + if + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 10 + call $~lib/number/I64#toString + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 16 + call $~lib/number/I64#toString + local.tee $5 + i32.store offset=8 + i32.const 5264 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $4 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5264 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $5 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5264 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $actualDisplay + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 10 + call $~lib/number/I64#toString + local.tee $7 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 16 + call $~lib/number/I64#toString + local.tee $8 + i32.store offset=24 + i32.const 5312 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $7 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5312 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $8 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5312 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $expectDisplay + i32.store offset=28 + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + call $assembly/test/Assert#get:errors + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $10 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $12 + i32.store offset=44 + i32.const 5360 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 1 + local.get $10 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5360 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 3 + local.get $11 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5360 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 5 + local.get $12 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5360 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit.test~anonymous|9 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281409993162479 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/reverse_bytes + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1171307680032161792 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 1888 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + call $start:assembly/arguments + call $start:assembly/memory + global.get $~lib/memory/__stack_pointer + i32.const 10 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 1792 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4464 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 4496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4560 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 4592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4656 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + i32.const 4688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4752 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + i32.const 4784 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4848 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 5 + i32.const 4880 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4944 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 6 + i32.const 4976 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 5024 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 7 + i32.const 5056 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 5104 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 8 + i32.const 5136 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 5184 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 9 + i32.const 5216 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 5408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/bit.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/staticJump (param $offset i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.StaticJump + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $offset + call $assembly/instructions/outcome/OutcomeData#set:staticJump + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/branch~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.eq + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.ne + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.lt_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.le_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.ge_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.gt_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.lt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.le_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.ge_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.gt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.eq + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ne + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_u + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ge_u + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ge_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) + (local $4 i32) + (local $5 i32) + (local $actualDisplay i32) + (local $7 i32) + (local $8 i32) + (local $expectDisplay i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $actual + local.get $expected + i32.ne + if + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 10 + call $~lib/number/U32#toString + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 16 + call $~lib/number/U32#toString + local.tee $5 + i32.store offset=8 + i32.const 6048 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $4 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6048 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $5 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6048 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $actualDisplay + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 10 + call $~lib/number/U32#toString + local.tee $7 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 16 + call $~lib/number/U32#toString + local.tee $8 + i32.store offset=24 + i32.const 6096 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $7 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6096 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $8 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6096 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $expectDisplay + i32.store offset=28 + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + call $assembly/test/Assert#get:errors + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $10 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $12 + i32.store offset=44 + i32.const 6144 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 1 + local.get $10 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6144 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 3 + local.get $11 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6144 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 5 + local.get $12 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6144 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch.test~anonymous|0 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 254 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const -559038737 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 254 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/branch/branch_eq_imm + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.StaticJump + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:staticJump + i32.const -559038737 + i32.const 6000 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/branch.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 1 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 5952 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 6192 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/branch.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.xor + i64.const -1 + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic.test~anonymous|0 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 3 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 15 + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 263882790666241 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/logic/and_inv + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 263882790666240 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/logic.test~anonymous|1 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 3 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 15 + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 263882790666241 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/logic/or_inv + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -15 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/logic.test~anonymous|2 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 3 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 15 + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 263882790666240 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/logic/xnor + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -263882790666256 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/logic.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 3 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 6512 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 6560 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 6592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 6624 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 6656 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 6688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/logic.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $c i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $c + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $c + i64.add + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.mul + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.const 4294967296 + i64.or + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i32.add + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 2 + i64.const 32 + call $~lib/math/ipow64 + i64.add + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + i64.sub + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.mul + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i32.div_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i32.MIN_VALUE + i64.extend_i32_s + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i32.rem_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i32) + (local $a i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i32.const -1 + i32.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i32.MIN_VALUE + i32.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + i64.extend_i32_s + local.get $a + i64.extend_i32_s + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.div_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i64.MIN_VALUE + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|18 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.rem_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|19 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i64.MIN_VALUE + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|20 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperSigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|21 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperUnsigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|22 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperSignedUnsigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|23 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.lt_s + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|24 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.lt_u + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|25 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.gt_s + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|26 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.gt_u + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math.test~anonymous|0 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 3 + i32.const 0 + call $assembly/arguments/Args.from + local.tee $args + i32.store + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=4 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/math/max + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 2 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/math.test~anonymous|1 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 3 + i32.const 0 + call $assembly/arguments/Args.from + local.tee $args + i32.store + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=4 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/math/max_u + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/math.test~anonymous|2 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 3 + i32.const 0 + call $assembly/arguments/Args.from + local.tee $args + i32.store + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=4 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/math/min + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/math.test~anonymous|3 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 3 + i32.const 0 + call $assembly/arguments/Args.from + local.tee $args + i32.store + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=4 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/math/min_u + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 2 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/math.test~anonymous|4 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 3 + i32.const 0 + call $assembly/arguments/Args.from + local.tee $args + i32.store + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=4 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + i64.const 64 + call $~lib/math/ipow64 + i64.const 1 + i64.sub + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + i64.const 64 + call $~lib/math/ipow64 + i64.const 1 + i64.sub + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/math/add_32 + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -2 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/math.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 5 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 7584 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 7616 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 7648 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 7680 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 7712 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 7744 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + i32.const 7776 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 7808 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + i32.const 7840 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 7872 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/math.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_l + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_l_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot.test~anonymous|0 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 8 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/rot/rot_r_64_imm + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1224979098630181442 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/rot.test~anonymous|1 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const -559038737 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 8 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/rot/rot_r_64_imm_alt + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1152921504609030722 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/rot.test~anonymous|2 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 8 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 8 + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/rot/rot_l_64 + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 956397711104 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/rot.test~anonymous|3 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 8 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 8 + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/rot/rot_l_32 + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1379995682 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/rot.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 8160 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 8208 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 8240 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 8304 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 8336 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 8384 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + i32.const 8416 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 8464 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/rot.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Chunks#constructor (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 30 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:fault + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:first + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:second + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory/Chunks#constructor@varargs (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $first + i32.store + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $second + i32.store offset=4 + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + local.get $first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + local.get $second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + local.get $4 + call $assembly/memory/Chunks#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory/PageData#constructor (param $this i32) (param $fault i32) (param $page i32) (param $relativeAddress i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 31 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/PageData#set:fault + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $page + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/PageData#set:page + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $relativeAddress + call $assembly/memory/PageData#set:relativeAddress + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory/fault (param $address i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isFault + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $address + call $assembly/memory/MaybePageFault#set:fault + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $"~lib/map/Map#get" (param $this i32) (param $key i32) (result i32) + (local $entry i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $key + local.get $key + call $~lib/util/hash/HASH + call $"~lib/map/Map#find" + local.set $entry + local.get $entry + i32.eqz + if + i32.const 8624 + i32.const 8688 + i32.const 105 + i32.const 17 + call $~lib/builtins/abort + unreachable + end + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory-page/Page#can (param $this i32) (param $access i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/Page#get:access + global.get $assembly/memory-page/Access.Write + i32.eq + if (result i32) + i32.const 1 + else + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/Page#get:access + local.get $access + i32.eq + end + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/Memory#getPage (param $this i32) (param $access i32) (param $address i32) (result i32) + (local $pageIdx i32) + (local $relAddress i32) + (local $pageStart i32) + (local $page i32) + (local $f i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $address + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $pageIdx + local.get $address + global.get $assembly/memory-page/PAGE_SIZE + i32.rem_u + local.set $relAddress + local.get $pageIdx + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + local.set $pageStart + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/memory/Memory#get:pages + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $pageIdx + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.get $pageStart + call $assembly/memory/fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory/EMPTY_PAGE + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/memory/Memory#get:pages + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $pageIdx + call $"~lib/map/Map#get" + local.tee $page + i32.store offset=8 + local.get $page + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $access + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $pageStart + call $assembly/memory/fault + local.tee $f + i32.store offset=12 + local.get $f + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isAccess + i32.const 0 + local.get $f + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory/EMPTY_PAGE + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $page + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/typedarray/Uint8Array#fill (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $value + local.get $start + local.get $end + call $~lib/util/bytes/FILL + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/typedarray/Uint8Array#fill@varargs (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $start + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $value + local.get $start + local.get $end + call $~lib/typedarray/Uint8Array#fill + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory-page/RawPage#get:data (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:page + i32.const 0 + i32.eq + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory-page/RawPage#set:page + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:page + local.tee $1 + i32.store offset=12 + local.get $1 + if (result i32) + local.get $1 + else + i32.const 8736 + i32.const 8864 + i32.const 46 + i32.const 12 + call $~lib/builtins/abort + unreachable + end + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/Memory#getChunks (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) + (local $pageData i32) + (local $page i32) + (local $relativeAddress i32) + (local $endAddress i32) + (local $needSecondPage i32) + (local $first i32) + (local $secondPageIdx i32) + (local $secondPageStart i32) + (local $secondPage i32) + (local $f i32) + (local $firstChunk i32) + (local $secondChunk i32) + (local $16 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + local.get $bytes + i32.const 255 + i32.and + i32.const 0 + i32.eq + if + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $access + local.get $address + call $assembly/memory/Memory#getPage + local.tee $pageData + i32.store offset=4 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/PageData#get:fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/MaybePageFault#get:isFault + if + i32.const 0 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/PageData#get:fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/PageData#get:page + local.tee $page + i32.store offset=12 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/PageData#get:relativeAddress + local.set $relativeAddress + local.get $relativeAddress + local.get $bytes + i32.const 255 + i32.and + i32.add + local.set $endAddress + local.get $endAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.gt_u + local.set $needSecondPage + local.get $needSecondPage + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $page + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $relativeAddress + local.get $endAddress + call $~lib/typedarray/Uint8Array#subarray + local.tee $first + i32.store offset=20 + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $first + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + i32.const 2 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + local.get $address + local.get $bytes + i32.const 255 + i32.and + i32.add + i64.extend_i32_u + global.get $assembly/memory/MEMORY_SIZE + i64.rem_s + i32.wrap_i64 + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $secondPageIdx + local.get $secondPageIdx + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + local.set $secondPageStart + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/Memory#get:pages + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $secondPageIdx + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.get $secondPageStart + call $assembly/memory/fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/Memory#get:pages + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $secondPageIdx + call $"~lib/map/Map#get" + local.tee $secondPage + i32.store offset=24 + local.get $secondPage + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $access + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $secondPageStart + call $assembly/memory/fault + local.tee $f + i32.store offset=28 + local.get $f + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isAccess + i32.const 0 + local.get $f + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $page + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $relativeAddress + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $firstChunk + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $secondPage + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + local.get $relativeAddress + local.get $bytes + i32.const 255 + i32.and + i32.add + global.get $assembly/memory-page/PAGE_SIZE + i32.sub + call $~lib/typedarray/Uint8Array#subarray + local.tee $secondChunk + i32.store offset=36 + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $firstChunk + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + local.get $secondChunk + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory/Chunks#constructor + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + ) + (func $assembly/memory/ChunkBytes#constructor (param $this i32) (param $fault i32) (param $bytes i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 28 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $fault + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory/ChunkBytes#set:fault + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $bytes + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory/ChunkBytes#set:bytes + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory/ChunkBytes#constructor@varargs (param $this i32) (param $fault i32) (param $bytes i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/staticarray/StaticArray#constructor + local.tee $bytes + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $fault + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $bytes + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/memory/ChunkBytes#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/getBytes (param $bytes i32) (param $first i32) (param $second i32) (result i32) + (local $res i32) + (local $len i32) + (local $i i32) + (local $i|6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $bytes + i32.const 255 + i32.and + call $~lib/staticarray/StaticArray#constructor + local.tee $res + i32.store + local.get $first + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $i + local.get $first + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|6 + loop $for-loop|1 + local.get $i|6 + local.get $second + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $len + local.get $i|6 + i32.add + local.get $second + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + local.get $i|6 + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $i|6 + i32.const 1 + i32.add + local.set $i|6 + br $for-loop|1 + end + end + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $assembly/memory/Memory#getBytes (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) + (local $res i32) + (local $data i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $access + local.get $address + local.get $bytes + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $assembly/memory/MaybePageFault#get:isFault + if + i32.const 0 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/ChunkBytes#constructor@varargs + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + global.get $~lib/memory/__stack_pointer + local.get $bytes + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:first + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:second + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/getBytes + local.tee $data + i32.store offset=16 + i32.const 0 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/ChunkBytes#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/memory/Result#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 27 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/memory/Result#set:ok + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/Result#set:fault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory/Memory#getI8 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/u8SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU64 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 8 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 8 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 16 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 24 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 4 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 32 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 5 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 40 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 6 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 48 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 7 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 56 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) + (local $4 i32) + (local $5 i32) + (local $actualDisplay i32) + (local $7 i32) + (local $8 i32) + (local $expectDisplay i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $actual + i32.const 0 + i32.ne + local.get $expected + i32.const 0 + i32.ne + i32.ne + if + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 0 + call $~lib/number/Bool#toString + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 16 + call $~lib/number/Bool#toString + local.tee $5 + i32.store offset=8 + i32.const 8992 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $4 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 8992 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $5 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 8992 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $actualDisplay + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 0 + call $~lib/number/Bool#toString + local.tee $7 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 16 + call $~lib/number/Bool#toString + local.tee $8 + i32.store offset=24 + i32.const 9104 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $7 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 9104 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $8 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 9104 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $expectDisplay + i32.store offset=28 + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + call $assembly/test/Assert#get:errors + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $10 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $12 + i32.store offset=44 + i32.const 9152 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 1 + local.get $10 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 9152 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 3 + local.get $11 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 9152 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 5 + local.get $12 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 9152 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/memory.test~anonymous|0 (param $$0 i32) (result i32) + (local $mem i32) + (local $a i32) + (local $b i32) + (local $assert i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $mem + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $assembly/memory/Memory#getI8 + local.tee $a + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + global.get $assembly/memory-page/RESERVED_MEMORY + i32.const 1 + i32.sub + call $assembly/memory/Memory#getU64 + local.tee $b + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=16 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $a + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 1 + i32.const 8944 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $a + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9200 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $a + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:fault + i32.const 0 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $b + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 1 + i32.const 9248 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $b + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9296 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $b + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:fault + i32.const 61440 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/string/String#concat (param $this i32) (param $other i32) (result i32) + (local $thisSize i32) + (local $otherSize i32) + (local $outSize i32) + (local $out i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $thisSize + local.get $other + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $otherSize + local.get $thisSize + local.get $otherSize + i32.add + local.set $outSize + local.get $outSize + i32.const 0 + i32.eq + if + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $out + local.get $this + local.get $thisSize + memory.copy + local.get $out + local.get $thisSize + i32.add + local.get $other + local.get $otherSize + memory.copy + local.get $out + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#pop (param $this i32) (result i32) + (local $len i32) + (local $val i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + local.set $len + local.get $len + i32.const 1 + i32.lt_s + if + i32.const 9584 + i32.const 1888 + i32.const 271 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $len + i32.const 1 + i32.sub + local.tee $len + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $val + i32.store offset=4 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $len + call $~lib/array/Array#set:length_ + local.get $val + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/console/console.log (param $message i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $message + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/bindings/dom/console.log + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory-page/Arena#acquire (param $this i32) (result i32) + (local $allocatedMemory i32) + (local $data i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:free + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + i32.const 0 + i32.gt_s + if + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:free + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#pop + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.set $allocatedMemory + local.get $allocatedMemory + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/Arena#get:arenaBytes + i32.eq + if + i32.const 9632 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/console/console.log + end + global.get $~lib/memory/__stack_pointer + local.get $allocatedMemory + global.get $assembly/memory-page/ALLOCATE_EAGERLY + i32.lt_u + if (result i32) + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + else + i32.const 0 + end + local.tee $data + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + i32.const 1 + i32.add + call $assembly/memory-page/Arena#set:extraPageIndex + i32.const 0 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/RawPage#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) + (local $newBucketsCapacity i32) + (local $newBuckets i32) + (local $newEntriesCapacity i32) + (local $newEntries i32) + (local $oldPtr i32) + (local $oldEnd i32) + (local $newPtr i32) + (local $oldEntry i32) + (local $newEntry i32) + (local $oldEntryKey i32) + (local $newBucketIndex i32) + (local $newBucketPtrBase i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $newBucketsMask + i32.const 1 + i32.add + local.set $newBucketsCapacity + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $newBucketsCapacity + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newBuckets + i32.store + local.get $newBucketsCapacity + i32.const 8 + i32.mul + i32.const 3 + i32.div_s + local.set $newEntriesCapacity + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $newEntriesCapacity + block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.1" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newEntries + i32.store offset=4 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entries" + local.set $oldPtr + local.get $oldPtr + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.2" + end + i32.mul + i32.add + local.set $oldEnd + local.get $newEntries + local.set $newPtr + loop $while-continue|0 + local.get $oldPtr + local.get $oldEnd + i32.ne + if + local.get $oldPtr + local.set $oldEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $newPtr + local.set $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:key" + local.set $oldEntryKey + local.get $newEntry + local.get $oldEntryKey + call $"~lib/map/MapEntry#set:key" + local.get $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:value" + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/MapEntry#set:value" + local.get $oldEntryKey + call $~lib/util/hash/HASH + local.get $newBucketsMask + i32.and + local.set $newBucketIndex + local.get $newBuckets + local.get $newBucketIndex + i32.const 4 + i32.mul + i32.add + local.set $newBucketPtrBase + local.get $newEntry + local.get $newBucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $newBucketPtrBase + local.get $newPtr + i32.store + local.get $newPtr + block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.3" + end + i32.add + local.set $newPtr + end + local.get $oldPtr + block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.4" + end + i32.add + local.set $oldPtr + br $while-continue|0 + end + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBuckets + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBucketsMask + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntries + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntriesCapacity + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#get:entriesCount" + call $"~lib/map/Map#set:entriesOffset" + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) + (local $hashCode i32) + (local $entry i32) + (local $entries i32) + (local $6 i32) + (local $bucketPtrBase i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $key + call $~lib/util/hash/HASH + local.set $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $key + local.get $hashCode + call $"~lib/map/Map#find" + local.set $entry + local.get $entry + if + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.eq + if + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.const 3 + i32.mul + i32.const 4 + i32.div_s + i32.lt_s + if (result i32) + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.const 1 + i32.shl + i32.const 1 + i32.or + end + call $"~lib/map/Map#rehash" + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.tee $entries + i32.store offset=8 + local.get $entries + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.tee $6 + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesOffset" + local.get $6 + block $"~lib/map/ENTRY_SIZE|inlined.5" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.5" + end + i32.mul + i32.add + local.set $entry + local.get $entry + local.get $key + call $"~lib/map/MapEntry#set:key" + i32.const 0 + drop + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + local.set $bucketPtrBase + local.get $entry + local.get $bucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $bucketPtrBase + local.get $entry + i32.store + end + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/memory/MemoryBuilder#getOrCreatePageForAddress (param $this i32) (param $access i32) (param $address i32) (result i32) + (local $pageIdx i32) + (local $page i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $address + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $pageIdx + local.get $pageIdx + global.get $assembly/memory-page/RESERVED_PAGES + i32.lt_u + if + i32.const 9488 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + i32.const 10 + call $~lib/number/U32#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/string/String#concat + i32.const 2048 + i32.const 93 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/MemoryBuilder#get:pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + call $"~lib/map/Map#has" + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/MemoryBuilder#get:arena + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=8 + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/MemoryBuilder#get:pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + i32.const 0 + local.get $access + local.get $page + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory-page/Page#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $"~lib/map/Map#set" + drop + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/MemoryBuilder#get:pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + call $"~lib/map/Map#get" + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.set $sourceStart + i32.const 0 + i32.eqz + drop + local.get $targetStart + local.get $sourceStart + local.get $sourceLen + i32.const 0 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/MemoryBuilder#setData (param $this i32) (param $access i32) (param $address i32) (param $data i32) (result i32) + (local $currentAddress i32) + (local $currentData i32) + (local $page i32) + (local $relAddress i32) + (local $spaceInPage i32) + (local $end i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $address + local.set $currentAddress + global.get $~lib/memory/__stack_pointer + local.get $data + local.tee $currentData + i32.store + loop $while-continue|0 + local.get $currentData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $access + local.get $currentAddress + call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress + local.tee $page + i32.store offset=8 + local.get $currentAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.rem_u + local.set $relAddress + global.get $assembly/memory-page/PAGE_SIZE + local.get $relAddress + i32.sub + local.set $spaceInPage + local.get $currentData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + local.get $spaceInPage + i32.lt_u + if (result i32) + local.get $currentData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + else + local.get $spaceInPage + end + local.set $end + local.get $page + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=20 + local.get $10 + call $assembly/memory-page/Page#get:raw + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=16 + local.get $10 + call $assembly/memory-page/RawPage#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $currentData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=16 + local.get $10 + i32.const 0 + local.get $end + call $~lib/typedarray/Uint8Array#subarray + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + local.get $relAddress + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $currentAddress + local.get $end + i32.add + local.set $currentAddress + global.get $~lib/memory/__stack_pointer + local.get $currentData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $end + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $currentData + i32.store + br $while-continue|0 + end + end + local.get $this + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $assembly/memory/Memory#getU8 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/typedarray/Uint8Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + i32.ge_u + if + i32.const 480 + i32.const 720 + i32.const 178 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $index + i32.add + local.get $value + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU8 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 1 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/memory.test~anonymous|1 (param $$0 i32) (result i32) + (local $builder i32) + (local $mem i32) + (local $a i32) + (local $b i32) + (local $c i32) + (local $d i32) + (local $assert i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store + local.get $builder + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $assembly/memory-page/Access.Read + global.get $assembly/memory-page/RESERVED_MEMORY + i32.const 0 + i32.const 10 + call $~lib/typedarray/Uint8Array#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/MemoryBuilder#setData + drop + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $mem + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $assembly/memory-page/RESERVED_MEMORY + call $assembly/memory/Memory#getU64 + local.tee $a + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $assembly/memory-page/RESERVED_PAGES + i32.const 1 + i32.add + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + call $assembly/memory/Memory#getU8 + local.tee $b + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $assembly/memory-page/RESERVED_MEMORY + i32.const 12 + call $assembly/memory/Memory#setU8 + local.tee $c + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $assembly/memory-page/RESERVED_MEMORY + call $assembly/memory/Memory#getU8 + local.tee $d + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=32 + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $a + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=40 + local.get $8 + call $assembly/memory/Result#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 8944 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $a + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=40 + local.get $8 + call $assembly/memory/Result#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9200 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $a + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/Result#get:ok + i64.const 0 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $b + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=40 + local.get $8 + call $assembly/memory/Result#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 1 + i32.const 9248 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $b + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=40 + local.get $8 + call $assembly/memory/Result#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9296 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $b + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=40 + local.get $8 + call $assembly/memory/Result#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:fault + i32.const 69632 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 1 + i32.const 9728 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 1 + i32.const 9776 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:fault + i32.const 65536 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $d + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/Result#get:ok + i64.const 0 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $i i32) + (local $ptr i32) + (local $value i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/array/Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/array/Array#get:dataStart + local.set $sourceStart + i32.const 0 + i32.const 2 + i32.eq + drop + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $sourceLen + i32.lt_s + if + local.get $targetStart + local.get $i + i32.const 0 + i32.shl + i32.add + local.set $ptr + local.get $sourceStart + local.get $i + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + i32.const 0 + drop + local.get $ptr + local.get $value + i32.store8 + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#bytesWrite (param $this i32) (param $address i32) (param $source i32) (result i32) + (local $nextAddress i32) + (local $sourceIndex i32) + (local $bytesLeft i32) + (local $pageData i32) + (local $relAddress i32) + (local $bytesToWrite i32) + (local $sourceData i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + local.get $address + local.set $nextAddress + i32.const 0 + local.set $sourceIndex + loop $while-continue|0 + local.get $sourceIndex + local.get $source + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $source + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + local.get $sourceIndex + i32.sub + local.set $bytesLeft + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + global.get $assembly/memory-page/Access.Write + local.get $nextAddress + call $assembly/memory/Memory#getPage + local.tee $pageData + i32.store offset=4 + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/PageData#get:fault + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:fault + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + end + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:relativeAddress + local.set $relAddress + local.get $relAddress + local.get $bytesLeft + i32.add + global.get $assembly/memory-page/PAGE_SIZE + i32.lt_u + if (result i32) + local.get $bytesLeft + else + global.get $assembly/memory-page/PAGE_SIZE + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:relativeAddress + i32.sub + end + local.set $bytesToWrite + global.get $~lib/memory/__stack_pointer + local.get $source + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $sourceIndex + local.get $sourceIndex + local.get $bytesToWrite + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $sourceData + i32.store offset=12 + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=24 + local.get $10 + call $assembly/memory/PageData#get:page + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=20 + local.get $10 + call $assembly/memory-page/Page#get:raw + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=16 + local.get $10 + call $assembly/memory-page/RawPage#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $sourceData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + local.get $relAddress + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $sourceIndex + local.get $bytesToWrite + i32.add + local.set $sourceIndex + local.get $nextAddress + local.get $bytesToWrite + i32.add + local.set $nextAddress + br $while-continue|0 + end + end + global.get $assembly/memory/NO_PAGE_FAULT + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $assembly/memory/Memory#bytesRead (param $this i32) (param $address i32) (param $destination i32) (result i32) + (local $nextAddress i32) + (local $destinationIndex i32) + (local $bytesLeft i32) + (local $pageData i32) + (local $relAddress i32) + (local $bytesToRead i32) + (local $source i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $address + local.set $nextAddress + i32.const 0 + local.set $destinationIndex + loop $while-continue|0 + local.get $destinationIndex + local.get $destination + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $destination + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + local.get $destinationIndex + i32.sub + local.set $bytesLeft + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + global.get $assembly/memory-page/Access.Read + local.get $nextAddress + call $assembly/memory/Memory#getPage + local.tee $pageData + i32.store offset=4 + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/PageData#get:fault + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:fault + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + end + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:relativeAddress + local.set $relAddress + local.get $relAddress + local.get $bytesLeft + i32.add + global.get $assembly/memory-page/PAGE_SIZE + i32.lt_u + if (result i32) + local.get $bytesLeft + else + global.get $assembly/memory-page/PAGE_SIZE + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:relativeAddress + i32.sub + end + local.set $bytesToRead + global.get $~lib/memory/__stack_pointer + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=16 + local.get $10 + call $assembly/memory/PageData#get:page + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/memory-page/Page#get:raw + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory-page/RawPage#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $relAddress + local.get $relAddress + local.get $bytesToRead + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $source + i32.store offset=20 + local.get $destination + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $source + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + local.get $destinationIndex + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $destinationIndex + local.get $bytesToRead + i32.add + local.set $destinationIndex + local.get $nextAddress + local.get $bytesToRead + i32.add + local.set $nextAddress + br $while-continue|0 + end + end + global.get $assembly/memory/NO_PAGE_FAULT + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $~lib/string/String#substring (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $len i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $finalStart i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $finalEnd i32) + (local $14 i32) + (local $15 i32) + (local $fromPos i32) + (local $17 i32) + (local $18 i32) + (local $toPos i32) + (local $size i32) + (local $out i32) + (local $22 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $~lib/string/String#get:length + local.set $len + local.get $start + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + local.tee $6 + local.get $len + local.tee $7 + local.get $6 + local.get $7 + i32.lt_s + select + local.set $finalStart + local.get $end + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_s + select + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + local.set $finalEnd + local.get $finalStart + local.tee $14 + local.get $finalEnd + local.tee $15 + local.get $14 + local.get $15 + i32.lt_s + select + i32.const 1 + i32.shl + local.set $fromPos + local.get $finalStart + local.tee $17 + local.get $finalEnd + local.tee $18 + local.get $17 + local.get $18 + i32.gt_s + select + i32.const 1 + i32.shl + local.set $toPos + local.get $toPos + local.get $fromPos + i32.sub + local.set $size + local.get $size + i32.eqz + if + i32.const 4080 + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + end + local.get $fromPos + i32.eqz + if (result i32) + local.get $toPos + local.get $len + i32.const 1 + i32.shl + i32.eq + else + i32.const 0 + end + if + local.get $this + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + end + global.get $~lib/memory/__stack_pointer + local.get $size + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $out + local.get $this + local.get $fromPos + i32.add + local.get $size + memory.copy + local.get $out + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + ) + (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $value i32) + (local $sepLen i32) + (local $estLen i32) + (local $result i32) + (local $offset i32) + (local $value|9 i32) + (local $i i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 4080 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $lastIndex + i32.eqz + if + local.get $dataStart + i32.load8_u + local.set $value + i32.const 0 + drop + i32.const 1 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 10 + call $~lib/util/number/utoa32 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $separator + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + local.set $sepLen + i32.const 10 + local.get $sepLen + i32.add + local.get $lastIndex + i32.mul + i32.const 10 + i32.add + local.set $estLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=4 + i32.const 0 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $lastIndex + i32.lt_s + if + local.get $dataStart + local.get $i + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $dataStart + local.get $lastIndex + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $estLen + local.get $offset + i32.gt_s + if + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.const 0 + local.get $offset + call $~lib/string/String#substring + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/typedarray/Uint8Array#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/typedarray/Uint8Array#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/util/string/joinIntegerArray + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/typedarray/Uint8Array#toString (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 10000 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/typedarray/Uint8Array#join + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/string/String.__eq (param $left i32) (param $right i32) (result i32) + (local $leftLength i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $left + local.get $right + i32.eq + if + i32.const 1 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $left + i32.const 0 + i32.eq + if (result i32) + i32.const 1 + else + local.get $right + i32.const 0 + i32.eq + end + if + i32.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $left + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/string/String#get:length + local.set $leftLength + local.get $leftLength + local.get $right + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/string/String#get:length + i32.ne + if + i32.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $left + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + local.get $right + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + local.get $leftLength + call $~lib/util/string/compareImpl + i32.eqz + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/string/String.__ne (param $left i32) (param $right i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $left + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $right + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/string/String.__eq + i32.eqz + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/test/Assert#isEqual<~lib/string/String> (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) + (local $actualDisplay i32) + (local $expectDisplay i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + local.get $actual + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $expected + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/string/String.__ne + if + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + local.get $actual + local.tee $actualDisplay + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $expected + local.tee $expectDisplay + i32.store offset=12 + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + call $assembly/test/Assert#get:errors + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $6 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $7 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $8 + i32.store offset=28 + i32.const 10128 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 1 + local.get $6 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=32 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 10128 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 3 + local.get $7 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=32 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 10128 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 5 + local.get $8 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=32 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 10128 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 4080 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=32 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/memory.test~anonymous|2 (param $$0 i32) (result i32) + (local $builder i32) + (local $mem i32) + (local $out i32) + (local $data i32) + (local $5 i32) + (local $a i32) + (local $b i32) + (local $c i32) + (local $assert i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + global.get $assembly/memory-page/Access.Write + global.get $assembly/memory-page/RESERVED_MEMORY + i32.const 0 + i32.const 1 + call $~lib/typedarray/Uint8Array#constructor + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/MemoryBuilder#setData + drop + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + global.get $assembly/memory-page/Access.Write + global.get $assembly/memory-page/RESERVED_PAGES + i32.const 1 + i32.add + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + i32.const 0 + i32.const 1 + call $~lib/typedarray/Uint8Array#constructor + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/MemoryBuilder#setData + drop + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $mem + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 16 + call $~lib/typedarray/Uint8Array#constructor + local.tee $out + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $out + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $data + i32.store offset=20 + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + i32.const 4 + i32.const 2 + i32.const 4 + i32.const 9952 + call $~lib/rt/__newArray + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + i32.const 0 + call $~lib/typedarray/Uint8Array#set<~lib/array/Array> + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/PAGE_SIZE + i32.add + i32.const 10 + i32.sub + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/Memory#bytesWrite + local.tee $a + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/PAGE_SIZE + i32.add + i32.const 9 + i32.sub + local.get $out + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/Memory#bytesRead + local.tee $b + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/PAGE_SIZE + i32.const 2 + i32.mul + i32.add + local.get $out + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/Memory#bytesRead + local.tee $c + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=36 + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $a + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 8944 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $a + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9200 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $a + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:fault + i32.const 0 + i32.const 8944 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $b + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 9248 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $b + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9296 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $b + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:fault + i32.const 0 + i32.const 9248 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $c + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 1 + i32.const 9728 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $c + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9776 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $out + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=48 + local.get $10 + call $~lib/typedarray/Uint8Array#toString + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + i32.const 10032 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + i32.const 4080 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=44 + local.get $10 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=48 + local.get $10 + call $~lib/typedarray/Uint8Array#toString + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + i32.const 10176 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + i32.const 4080 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=44 + local.get $10 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $start:assembly/memory.test~anonymous|3 (param $$0 i32) (result i32) + (local $mem i32) + (local $out i32) + (local $a i32) + (local $b i32) + (local $c i32) + (local $d i32) + (local $e i32) + (local $assert i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + global.get $assembly/memory-page/Access.Read + global.get $assembly/memory-page/RESERVED_MEMORY + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MemoryBuilder#setData + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $mem + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.tee $out + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 0 + local.get $out + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/memory/Memory#bytesRead + local.tee $a + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 0 + local.get $out + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/memory/Memory#bytesWrite + local.tee $b + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/RESERVED_MEMORY + i32.add + local.get $out + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/memory/Memory#bytesRead + local.tee $c + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/RESERVED_MEMORY + i32.add + local.get $out + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/memory/Memory#bytesRead + local.tee $d + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + global.get $assembly/memory-page/RESERVED_MEMORY + local.get $out + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/memory/Memory#bytesWrite + local.tee $e + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=40 + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $a + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 8944 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $b + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 9248 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $c + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 9728 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $d + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 10448 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $e + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 10496 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $start:assembly/memory.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 8496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 9344 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 9376 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 9824 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 9856 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 10288 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + i32.const 10320 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 10544 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/memory.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/jump~anonymous|0 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:a + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/instructions/outcome/dJump (param $address i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.DynamicJump + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $address + call $assembly/instructions/outcome/OutcomeData#set:dJump + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/jump~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $address i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + local.get $address + call $assembly/instructions/outcome/dJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/jump~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/jump~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $address i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:d + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + local.get $address + call $assembly/instructions/outcome/dJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.const 32 + i64.shl + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/load~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/instructions/outcome/okOrFault (param $pageFault i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MaybePageFault#get:isAccess + if (result i32) + global.get $assembly/instructions/outcome/Result.FAULT_ACCESS + else + global.get $assembly/instructions/outcome/Result.FAULT + end + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MaybePageFault#get:fault + call $assembly/instructions/outcome/OutcomeData#set:exitCode + end + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/load~anonymous|2 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|3 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU16 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getI16 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $l i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/Result#set:fault + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.const 15 + i32.and + i32.shl + i32.or + local.set $l + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $l + call $assembly/instructions/utils/u16SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU32 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getI32 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $l i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/Result#set:fault + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i32.or + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i32.or + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i32.or + local.set $l + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $l + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU64 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU64 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/mov~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/set~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.lt_u + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.lt_s + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.gt_u + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.gt_s + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_u + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/set~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_s + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/shift~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $imm i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $imm + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $imm + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $regValue i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $regValue + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regValue + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|0 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU16 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 2 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.gt_s + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $value + i32.const 65535 + i32.and + i32.const 8 + i32.const 15 + i32.and + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + else + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 65535 + i32.and + i32.const 8 + i32.const 15 + i32.and + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|1 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU32 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $v i32) + (local $len i32) + (local $i i32) + (local $i|7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 4 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $value + local.set $v + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + local.get $v + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i32.const 8 + i32.shr_u + local.set $v + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i|7 + local.get $v + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i32.const 8 + i32.shr_u + local.set $v + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/instructions/store~anonymous|2 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#setU32 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU64 (param $this i32) (param $address i32) (param $value i64) (result i32) + (local $res i32) + (local $v i64) + (local $len i32) + (local $i i32) + (local $i|7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 8 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $value + local.set $v + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + local.get $v + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i64.const 8 + i64.shr_u + local.set $v + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i|7 + local.get $v + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i64.const 8 + i64.shr_u + local.set $v + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/instructions/store~anonymous|3 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Memory#setU64 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/memory/Memory#setU32 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Memory#setU64 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/instructions/outcome/status (param $result i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $result + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Result.HOST + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $id + call $assembly/instructions/outcome/OutcomeData#set:exitCode + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:a + call $assembly/instructions/outcome/hostCall + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) + (local $freeMemoryStart i32) + (local $newSbrk i64) + (local $pageIdx i32) + (local $i i32) + (local $page i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $freeMemoryStart + i32.store + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $amount + i32.const 0 + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + local.get $amount + i64.extend_i32_u + i64.add + local.set $newSbrk + local.get $newSbrk + global.get $assembly/memory/MEMORY_SIZE + i64.ge_s + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Result#get:fault + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isFault + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $newSbrk + i32.wrap_i64 + call $assembly/memory/Memory#set:sbrkAddress + local.get $newSbrk + i64.const 1 + i64.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + local.set $pageIdx + local.get $pageIdx + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.const 1 + i32.add + local.set $i + loop $for-loop|0 + local.get $i + local.get $pageIdx + i32.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:arena + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=12 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory/Memory#get:pages + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $i + i32.const 0 + global.get $assembly/memory-page/Access.Write + local.get $page + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory-page/Page#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $"~lib/map/Map#set" + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $pageIdx + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#sbrk + local.tee $res + i32.store offset=12 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/codec~anonymous|0 (param $firstByte i32) (result i32) + (local $len i32) + (local $i i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $assembly/codec/MASKS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.const 255 + i32.and + i32.lt_u + if + local.get $firstByte + i32.const 255 + i32.and + global.get $assembly/codec/MASKS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $i + call $~lib/array/Array#__get + i32.ge_u + if + i32.const 8 + local.get $i + i32.sub + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 1888 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 13920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/MISSING_INSTRUCTION + i32.const 13968 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/SBRK + global.get $~lib/memory/__stack_pointer + i32.const 231 + i32.const 2 + i32.const 36 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.const 14000 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 14032 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 5 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 6 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 7 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 8 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 9 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 10 + i32.const 14080 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 11 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 12 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 13 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 14 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 15 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 16 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 17 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 18 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 19 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 20 + i32.const 14112 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneExtImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 21 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 22 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 23 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 24 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 25 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 26 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 27 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 28 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 29 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 30 + i32.const 14160 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 31 + i32.const 14208 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 32 + i32.const 14256 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 33 + i32.const 14304 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 34 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 35 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 36 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 37 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 38 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 39 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 40 + i32.const 14352 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 41 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 42 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 43 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 44 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 45 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 46 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 47 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 48 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 49 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 50 + i32.const 14384 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 51 + i32.const 14432 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 52 + i32.const 14480 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 53 + i32.const 14528 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 54 + i32.const 14576 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 55 + i32.const 14624 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 56 + i32.const 14672 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 57 + i32.const 14720 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 58 + i32.const 14768 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 59 + i32.const 14816 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 60 + i32.const 14864 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 61 + i32.const 14912 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 62 + i32.const 14960 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 63 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 64 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 65 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 66 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 67 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 68 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 69 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 70 + i32.const 15008 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 71 + i32.const 15072 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 72 + i32.const 15136 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 73 + i32.const 15200 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 74 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 75 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 76 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 77 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 78 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 79 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 80 + i32.const 15264 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 81 + i32.const 15312 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 82 + i32.const 15360 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 83 + i32.const 15408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 84 + i32.const 15472 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 85 + i32.const 15536 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 86 + i32.const 15600 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 87 + i32.const 15664 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 88 + i32.const 15728 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 89 + i32.const 15792 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 90 + i32.const 15856 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 91 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 92 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 93 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 94 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 95 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 96 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 97 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 98 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 99 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 100 + i32.const 15920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 101 + global.get $assembly/instructions/SBRK + call $~lib/array/Array#__set + local.get $0 + i32.const 102 + i32.const 15968 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 103 + i32.const 16032 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 104 + i32.const 16096 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 105 + i32.const 16160 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 106 + i32.const 16224 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 107 + i32.const 16288 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 108 + i32.const 16352 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 109 + i32.const 16400 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 110 + i32.const 16448 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 111 + i32.const 16496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 112 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 113 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 114 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 115 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 116 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 117 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 118 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 119 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 120 + i32.const 16544 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 121 + i32.const 16592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 122 + i32.const 16640 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 123 + i32.const 16688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 124 + i32.const 16736 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 125 + i32.const 16784 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 126 + i32.const 16832 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 127 + i32.const 16880 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 128 + i32.const 16928 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 129 + i32.const 16976 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 130 + i32.const 17024 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 131 + i32.const 17072 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 132 + i32.const 17120 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 133 + i32.const 17168 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 134 + i32.const 17216 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 135 + i32.const 17248 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 136 + i32.const 17296 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 137 + i32.const 17344 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 138 + i32.const 17392 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 139 + i32.const 17440 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 140 + i32.const 17488 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 141 + i32.const 17536 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 142 + i32.const 17584 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 143 + i32.const 17632 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 144 + i32.const 17680 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 145 + i32.const 17744 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 146 + i32.const 17808 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 147 + i32.const 17872 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 148 + i32.const 17920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 149 + i32.const 17968 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 150 + i32.const 18016 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 151 + i32.const 18064 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 152 + i32.const 18112 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 153 + i32.const 18160 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 154 + i32.const 18208 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 155 + i32.const 18256 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 156 + i32.const 18320 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 157 + i32.const 18384 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 158 + i32.const 18448 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 159 + i32.const 18496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 160 + i32.const 18560 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 161 + i32.const 18608 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 162 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 163 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 164 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 165 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 166 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 167 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 168 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 169 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 170 + i32.const 18672 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 171 + i32.const 18720 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 172 + i32.const 18768 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 173 + i32.const 18816 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 174 + i32.const 18864 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 175 + i32.const 18912 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 176 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 177 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 178 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 179 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 180 + i32.const 18960 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegTwoImm + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 181 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 182 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 183 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 184 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 185 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 186 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 187 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 188 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 189 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 190 + i32.const 19024 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 191 + i32.const 19056 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 192 + i32.const 19088 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 193 + i32.const 19120 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 194 + i32.const 19168 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 195 + i32.const 19216 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 196 + i32.const 19264 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 197 + i32.const 19312 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 198 + i32.const 19360 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 199 + i32.const 19408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 200 + i32.const 19456 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 201 + i32.const 19488 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 202 + i32.const 19520 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 203 + i32.const 19552 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 204 + i32.const 19600 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 205 + i32.const 19648 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 206 + i32.const 19696 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 207 + i32.const 19744 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 208 + i32.const 19792 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 209 + i32.const 19840 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 210 + i32.const 19888 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 211 + i32.const 19920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 212 + i32.const 19952 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 213 + i32.const 19984 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 214 + i32.const 20032 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 215 + i32.const 20080 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 216 + i32.const 20128 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 217 + i32.const 20176 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 218 + i32.const 20224 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 219 + i32.const 20272 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 220 + i32.const 20320 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 221 + i32.const 20368 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 222 + i32.const 20416 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 223 + i32.const 20464 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 224 + i32.const 20512 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 225 + i32.const 20560 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 226 + i32.const 20592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 227 + i32.const 20624 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 228 + i32.const 20656 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 229 + i32.const 20688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 230 + i32.const 20720 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/INSTRUCTIONS + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/Mask#constructor (param $this i32) (param $packedMask i32) (param $codeLength i32) (result i32) + (local $lastInstructionOffset i32) + (local $i i32) + (local $bits i32) + (local $index i32) + (local $b i32) + (local $isSet i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 37 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + call $assembly/program/Mask#set:bytesToSkip + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + local.get $codeLength + call $~lib/staticarray/StaticArray#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/Mask#set:bytesToSkip + i32.const 0 + local.set $lastInstructionOffset + local.get $packedMask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.sub + local.set $i + loop $for-loop|0 + local.get $i + i32.const 0 + i32.ge_s + if + local.get $packedMask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $bits + local.get $i + i32.const 8 + i32.mul + local.set $index + i32.const 7 + local.set $b + loop $for-loop|2 + local.get $b + i32.const 0 + i32.ge_s + if + local.get $bits + i32.const 128 + i32.and + local.set $isSet + local.get $bits + i32.const 1 + i32.const 7 + i32.and + i32.shl + local.set $bits + local.get $index + local.get $b + i32.add + local.get $codeLength + i32.lt_s + if + local.get $isSet + if (result i32) + i32.const 0 + else + local.get $lastInstructionOffset + i32.const 1 + i32.add + end + local.set $lastInstructionOffset + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/Mask#get:bytesToSkip + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $index + local.get $b + i32.add + local.get $lastInstructionOffset + global.get $assembly/program/MAX_SKIP + i32.const 1 + i32.add + i32.lt_u + if (result i32) + local.get $lastInstructionOffset + else + global.get $assembly/program/MAX_SKIP + i32.const 1 + i32.add + end + call $~lib/staticarray/StaticArray#__set + end + local.get $b + i32.const 1 + i32.sub + local.set $b + br $for-loop|2 + end + end + local.get $i + i32.const 1 + i32.sub + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $i i32) + (local $ptr i32) + (local $value f64) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/array/Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/array/Array#get:dataStart + local.set $sourceStart + i32.const 1 + i32.const 0 + i32.eq + drop + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $sourceLen + i32.lt_s + if + local.get $targetStart + local.get $i + i32.const 0 + i32.shl + i32.add + local.set $ptr + local.get $sourceStart + local.get $i + i32.const 3 + i32.shl + i32.add + f64.load + local.set $value + i32.const 0 + drop + i32.const 0 + i32.eqz + drop + local.get $ptr + local.get $value + local.get $value + f64.sub + f64.const 0 + f64.eq + if (result i32) + local.get $value + i32.trunc_sat_f64_u + else + i32.const 0 + end + i32.store8 + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program.test/u8arr (param $data i32) (result i32) + (local $ret i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $ret + i32.store offset=4 + local.get $ret + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#set<~lib/array/Array> + local.get $ret + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/staticarray/StaticArray#slice<~lib/array/Array> (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $length i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $sourceStart i32) + (local $size i32) + (local $out i32) + (local $outStart i32) + (local $18 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $18 + global.get $~lib/memory/__stack_pointer + local.get $18 + i32.store + local.get $18 + call $~lib/staticarray/StaticArray#get:length + local.set $length + local.get $start + i32.const 0 + i32.lt_s + if (result i32) + local.get $start + local.get $length + i32.add + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + else + local.get $start + local.tee $6 + local.get $length + local.tee $7 + local.get $6 + local.get $7 + i32.lt_s + select + end + local.set $start + local.get $end + i32.const 0 + i32.lt_s + if (result i32) + local.get $end + local.get $length + i32.add + local.tee $8 + i32.const 0 + local.tee $9 + local.get $8 + local.get $9 + i32.gt_s + select + else + local.get $end + local.tee $10 + local.get $length + local.tee $11 + local.get $10 + local.get $11 + i32.lt_s + select + end + local.set $end + local.get $end + local.get $start + i32.sub + local.tee $12 + i32.const 0 + local.tee $13 + local.get $12 + local.get $13 + i32.gt_s + select + local.set $length + local.get $this + local.get $start + i32.const 2 + i32.shl + i32.add + local.set $sourceStart + local.get $length + i32.const 2 + i32.shl + local.set $size + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $out + i32.store offset=4 + i32.const 1 + drop + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 2 + i32.const 40 + i32.const 0 + call $~lib/rt/__newArray + local.tee $out + i32.store offset=4 + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + local.get $18 + i32.store + local.get $18 + call $~lib/array/Array#get:dataStart + local.set $outStart + i32.const 0 + drop + local.get $outStart + local.get $sourceStart + local.get $size + memory.copy + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + ) + (func $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $start + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $start + local.get $end + call $~lib/staticarray/StaticArray#slice<~lib/array/Array> + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $value i32) + (local $sepLen i32) + (local $estLen i32) + (local $result i32) + (local $offset i32) + (local $value|9 i32) + (local $i i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 4080 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $lastIndex + i32.eqz + if + local.get $dataStart + i32.load + local.set $value + i32.const 0 + drop + i32.const 4 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 10 + call $~lib/util/number/utoa32 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $separator + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + local.set $sepLen + i32.const 10 + local.get $sepLen + i32.add + local.get $lastIndex + i32.mul + i32.const 10 + i32.add + local.set $estLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=4 + i32.const 0 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $lastIndex + i32.lt_s + if + local.get $dataStart + local.get $i + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $dataStart + local.get $lastIndex + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $estLen + local.get $offset + i32.gt_s + if + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.const 0 + local.get $offset + call $~lib/string/String#substring + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/array/Array#join (param $this i32) (param $separator i32) (result i32) + (local $ptr i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.set $ptr + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $len + i32.const 0 + drop + i32.const 1 + drop + local.get $ptr + local.get $len + local.get $separator + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/util/string/joinIntegerArray + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/test/Assert#isArrayEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $actual + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $~lib/array/Array#get:length + local.get $expected + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $~lib/array/Array#get:length + i32.const 21008 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $msg + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $~lib/string/String#concat + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/test/Assert#isEqual + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $actual + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + local.get $4 + i32.const 10000 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=24 + local.get $4 + call $~lib/array/Array#join + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $~lib/string/String#toString + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $expected + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + local.get $4 + i32.const 10000 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=24 + local.get $4 + call $~lib/array/Array#join + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $~lib/string/String#toString + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $msg + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/test/Assert#isEqual<~lib/string/String> + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/Mask#isInstruction (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + i64.extend_i32_u + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i64.extend_i32_s + i64.ge_u + if + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $index + call $~lib/staticarray/StaticArray#__get + i32.const 0 + i32.eq + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/program/Mask#skipBytesToNextInstruction (param $this i32) (param $i i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $i + i32.const 1 + i32.add + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i32.lt_u + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $i + i32.const 1 + i32.add + call $~lib/staticarray/StaticArray#__get + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/program.test~anonymous|0 (param $$0 i32) (result i32) + (local $1 i32) + (local $mask i32) + (local $assert i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 3 + i32.const 3 + i32.const 39 + i32.const 20848 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program.test/u8arr + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 21 + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/program/Mask#get:bytesToSkip + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + i32.const 0 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 21 + i32.const 2 + i32.const 40 + i32.const 20896 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isArrayEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 0 + call $assembly/program/Mask#isInstruction + i32.const 0 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 4 + call $assembly/program/Mask#isInstruction + i32.const 1 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 20 + call $assembly/program/Mask#skipBytesToNextInstruction + i32.const 0 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 22 + call $assembly/program/Mask#skipBytesToNextInstruction + i32.const 0 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/program.test~anonymous|1 (param $$0 i32) (result i32) + (local $1 i32) + (local $mask i32) + (local $assert i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 4 + i32.const 3 + i32.const 39 + i32.const 21200 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program.test/u8arr + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 32 + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/program/Mask#get:bytesToSkip + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + i32.const 0 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 32 + i32.const 2 + i32.const 40 + i32.const 21264 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isArrayEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 21616 + i32.const 1888 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/decodeArguments (param $kind i32) (param $data i32) (param $lim i32) (result i32) + (local $extended i32) + (local $i i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + global.get $assembly/arguments/REQUIRED_BYTES + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $kind + call $~lib/array/Array#__get + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/arguments/REQUIRED_BYTES + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $kind + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#constructor + local.tee $extended + i32.store offset=4 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $extended + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $extended + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $lim + i32.const 2 + global.set $~argumentsLength + global.get $assembly/arguments/DECODERS + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $kind + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $3) + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $lim + i32.const 2 + global.set $~argumentsLength + global.get $assembly/arguments/DECODERS + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $kind + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $3) + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/program.test~anonymous|2 (param $$0 i32) (result i32) + (local $1 i32) + (local $data i32) + (local $args i32) + (local $assert i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 3 + i32.const 39 + i32.const 21552 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program.test/u8arr + local.tee $data + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + global.get $assembly/arguments/Arguments.OneImm + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 4 + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:a + i32.const -1 + i32.const 21744 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 0 + i32.const 21776 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 0 + i32.const 21808 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:d + i32.const 0 + i32.const 21840 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/program.test~anonymous|3 (param $$0 i32) (result i32) + (local $1 i32) + (local $data i32) + (local $args i32) + (local $assert i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 2 + i32.const 3 + i32.const 39 + i32.const 22000 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program.test/u8arr + local.tee $data + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + global.get $assembly/arguments/Arguments.OneImm + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:a + i32.const 5 + i32.const 21744 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 0 + i32.const 21776 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 0 + i32.const 21808 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:d + i32.const 0 + i32.const 21840 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/codec/Decoder#constructor (param $this i32) (param $source i32) (param $offset i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 45 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $source + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/codec/Decoder#set:source + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $offset + call $assembly/codec/Decoder#set:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/codec/Decoder#ensureBytes (param $this i32) (param $need i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#get:offset + local.get $need + i32.add + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/codec/Decoder#get:source + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $need + i32.const 10 + call $~lib/number/U32#toString + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/codec/Decoder#get:source + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#get:offset + i32.sub + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=12 + i32.const 22624 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $2 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 22624 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 3 + local.get $3 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 22624 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 4080 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 22672 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/ValOffset#constructor (param $this i32) (param $value i32) (param $offset i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 46 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $value + call $assembly/codec/ValOffset#set:value + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $offset + call $assembly/codec/ValOffset#set:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/codec/decodeVarU32 (param $data i32) (result i32) + (local $length i32) + (local $first i32) + (local $3 i32) + (local $4 i32) + (local $msb i32) + (local $number i32) + (local $i i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + i32.const 1 + global.set $~argumentsLength + global.get $assembly/codec/variableLength + i32.load + call_indirect (type $0) + i32.const 255 + i32.and + local.set $length + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $first + local.get $length + i32.const 0 + i32.eq + if + i32.const 0 + local.get $first + i32.const 1 + call $assembly/codec/ValOffset#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.get $length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.const 10 + call $~lib/number/I32#toString + local.tee $4 + i32.store offset=8 + i32.const 22896 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $3 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 22896 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 3 + local.get $4 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 22896 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 22672 + i32.const 108 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $first + i32.const 2 + i32.const 8 + local.get $length + i32.sub + call $~lib/math/ipow32 + i32.add + i32.const 2 + i32.const 8 + call $~lib/math/ipow32 + i32.sub + local.get $length + i32.const 8 + i32.mul + i32.shl + local.set $msb + i32.const 0 + local.set $number + local.get $length + i32.const 1 + i32.sub + local.set $i + loop $for-loop|0 + local.get $i + i32.const 0 + i32.ge_s + if + local.get $number + i32.const 8 + i32.shl + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $i + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.add + local.set $number + local.get $i + i32.const 1 + i32.sub + local.set $i + br $for-loop|0 + end + end + local.get $number + local.get $msb + i32.add + local.set $number + i32.const 0 + local.get $number + i32.const 1 + local.get $length + i32.add + call $assembly/codec/ValOffset#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/codec/Decoder#varU32 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/codec/decodeVarU32 + local.tee $v + i32.store offset=12 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/ValOffset#get:offset + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/codec/ValOffset#get:value + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u8 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#bytes (param $this i32) (param $len i32) (result i32) + (local $v i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $len + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:source + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $len + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $v + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $len + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/JumpTable#constructor (param $this i32) (param $itemBytes i32) (param $data i32) (result i32) + (local $jumps i32) + (local $i i32) + (local $num i64) + (local $j i32) + (local $nextNum i64) + (local $isOverflow i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 42 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + call $assembly/program/JumpTable#set:jumps + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $itemBytes + i32.const 255 + i32.and + i32.const 0 + i32.gt_u + if (result i32) + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.get $itemBytes + i32.const 255 + i32.and + i32.div_s + else + i32.const 0 + end + call $~lib/staticarray/StaticArray#constructor + local.tee $jumps + i32.store offset=8 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + i64.const 0 + local.set $num + local.get $itemBytes + i32.const 1 + i32.sub + i32.const 255 + i32.and + local.set $j + loop $for-loop|1 + local.get $j + i32.const 0 + i32.ge_s + if + local.get $num + i64.const 8 + i64.shl + local.set $nextNum + local.get $nextNum + local.get $num + i64.lt_u + local.set $isOverflow + local.get $nextNum + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + local.get $j + i32.add + call $~lib/typedarray/Uint8Array#__get + i64.extend_i32_u + i64.add + local.set $nextNum + local.get $isOverflow + if (result i32) + i32.const 1 + else + local.get $nextNum + local.get $num + i64.lt_u + end + local.set $isOverflow + local.get $isOverflow + if (result i64) + global.get $~lib/builtins/u64.MAX_VALUE + else + local.get $nextNum + end + local.set $num + local.get $j + i32.const 1 + i32.sub + local.set $j + br $for-loop|1 + end + end + local.get $jumps + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + local.get $itemBytes + i32.const 255 + i32.and + i32.div_s + local.get $num + call $~lib/staticarray/StaticArray#__set + local.get $i + local.get $itemBytes + i32.const 255 + i32.and + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $jumps + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $assembly/program/JumpTable#set:jumps + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 21616 + i32.const 1888 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/BasicBlocks#constructor (param $this i32) (param $code i32) (param $mask i32) (result i32) + (local $len i32) + (local $isStartOrEnd i32) + (local $n i32) + (local $isInstructionInMask i32) + (local $skipArgs i32) + (local $iData i32) + (local $isTerminating i32) + (local $newBlockStart i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 43 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + call $assembly/program/BasicBlocks#set:isStartOrEnd + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $len + call $~lib/staticarray/StaticArray#constructor + local.tee $isStartOrEnd + i32.store offset=8 + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + i32.const 0 + local.set $n + loop $for-loop|0 + local.get $n + local.get $len + i32.lt_s + if + block $for-continue|0 + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $assembly/program/Mask#isInstruction + local.set $isInstructionInMask + local.get $isInstructionInMask + i32.eqz + if + br $for-continue|0 + end + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipArgs + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#__get + end + local.set $iData + local.get $iData + call $assembly/instructions/Instruction#get:isTerminating + local.set $isTerminating + local.get $isTerminating + if + local.get $n + i32.const 1 + i32.add + local.get $skipArgs + i32.add + local.set $newBlockStart + local.get $newBlockStart + local.get $len + i32.lt_s + if + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $newBlockStart + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + end + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + local.get $n + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.END + i32.or + call $~lib/staticarray/StaticArray#__set + end + end + local.get $n + i32.const 1 + i32.add + local.set $n + br $for-loop|0 + end + end + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + call $assembly/program/BasicBlocks#set:isStartOrEnd + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + ) + (func $assembly/program/Program#constructor (param $this i32) (param $code i32) (param $mask i32) (param $jumpTable i32) (param $basicBlocks i32) (result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 41 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $code + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:code + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:mask + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:jumpTable + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $basicBlocks + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:basicBlocks + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/program/deblob (param $program i32) (result i32) + (local $decoder i32) + (local $jumpTableLength i32) + (local $jumpTableItemLength i32) + (local $codeLength i32) + (local $jumpTableLengthInBytes i32) + (local $rawJumpTable i32) + (local $rawCode i32) + (local $rawMask i32) + (local $mask i32) + (local $jumpTable i32) + (local $basicBlocks i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $program + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#varU32 + local.set $jumpTableLength + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#u8 + local.set $jumpTableItemLength + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#varU32 + local.set $codeLength + local.get $jumpTableLength + local.get $jumpTableItemLength + i32.mul + local.set $jumpTableLengthInBytes + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $jumpTableLengthInBytes + call $assembly/codec/Decoder#bytes + local.tee $rawJumpTable + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + call $assembly/codec/Decoder#bytes + local.tee $rawCode + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + i32.const 7 + i32.add + i32.const 8 + i32.div_u + call $assembly/codec/Decoder#bytes + local.tee $rawMask + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $rawMask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $jumpTableItemLength + local.get $rawJumpTable + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/program/JumpTable#constructor + local.tee $jumpTable + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $rawCode + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $mask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=28 + local.get $12 + call $assembly/program/BasicBlocks#constructor + local.tee $basicBlocks + i32.store offset=32 + i32.const 0 + local.get $rawCode + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $mask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=28 + local.get $12 + local.get $jumpTable + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=36 + local.get $12 + local.get $basicBlocks + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=40 + local.get $12 + call $assembly/program/Program#constructor + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $~lib/string/String.__concat (param $left i32) (param $right i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $left + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $right + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/string/String#concat + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/program/Mask#toString (param $this i32) (result i32) + (local $v i32) + (local $i i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 22944 + local.tee $v + i32.store + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/program/Mask#get:bytesToSkip + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=24 + local.get $3 + call $assembly/program/Mask#get:bytesToSkip + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=20 + local.get $3 + local.get $i + call $~lib/staticarray/StaticArray#__get + i32.const 10 + call $~lib/number/U32#toString + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + i32.const 22976 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + call $~lib/string/String#concat + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $~lib/string/String.__concat + local.tee $v + i32.store + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $v + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 23008 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $~lib/string/String#concat + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/JumpTable#toString (param $this i32) (result i32) + (local $v i32) + (local $i i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 23280 + local.tee $v + i32.store + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/JumpTable#get:jumps + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $~lib/memory/__stack_pointer + local.get $i + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/program/JumpTable#get:jumps + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + local.get $i + call $~lib/staticarray/StaticArray#__get + i32.const 10 + call $~lib/number/U64#toString + local.tee $4 + i32.store offset=24 + i32.const 23360 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 0 + local.get $3 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 23360 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 2 + local.get $4 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 23360 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/string/String.__concat + local.tee $v + i32.store + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $v + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 23008 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/string/String#concat + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/program/BasicBlocks#toString (param $this i32) (result i32) + (local $v i32) + (local $i i32) + (local $t i32) + (local $isStart i32) + (local $isEnd i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 23456 + local.tee $v + i32.store + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 4080 + local.tee $t + i32.store offset=12 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $i + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.START + i32.and + i32.const 0 + i32.gt_s + local.set $isStart + global.get $~lib/memory/__stack_pointer + local.get $t + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $isStart + if (result i32) + i32.const 23504 + else + i32.const 4080 + end + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String.__concat + local.tee $t + i32.store offset=12 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $i + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.END + i32.and + i32.const 0 + i32.gt_s + local.set $isEnd + global.get $~lib/memory/__stack_pointer + local.get $t + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $isEnd + if (result i32) + i32.const 23536 + else + i32.const 4080 + end + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String.__concat + local.tee $t + i32.store offset=12 + local.get $t + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $~lib/string/String#get:length + i32.const 0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $~lib/memory/__stack_pointer + local.get $i + i32.const 10 + call $~lib/number/I32#toString + local.tee $6 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $t + local.tee $7 + i32.store offset=20 + i32.const 23568 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 0 + local.get $6 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 23568 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 2 + local.get $7 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 23568 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String.__concat + local.tee $v + i32.store + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $v + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 23008 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/program.test~anonymous|4 (param $$0 i32) (result i32) + (local $1 i32) + (local $raw i32) + (local $program i32) + (local $assert i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 41 + i32.const 3 + i32.const 39 + i32.const 22144 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program.test/u8arr + local.tee $raw + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $raw + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program/deblob + local.tee $program + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $program + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=32 + local.get $5 + call $assembly/program/Program#get:mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/program/Mask#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 23040 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $program + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=32 + local.get $5 + call $assembly/program/Program#get:jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/program/JumpTable#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 23408 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $program + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=32 + local.get $5 + call $assembly/program/Program#get:basicBlocks + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/program/BasicBlocks#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 23616 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#indexOf (param $this i32) (param $value i32) (param $fromIndex i32) (result i32) + (local $len i32) + (local $4 i32) + (local $5 i32) + (local $ptr i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ + local.set $len + local.get $len + i32.const 0 + i32.eq + if (result i32) + i32.const 1 + else + local.get $fromIndex + local.get $len + i32.ge_s + end + if + i32.const -1 + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $fromIndex + i32.const 0 + i32.lt_s + if + local.get $len + local.get $fromIndex + i32.add + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + local.set $fromIndex + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart + local.set $ptr + loop $while-continue|0 + local.get $fromIndex + local.get $len + i32.lt_s + if + local.get $ptr + local.get $fromIndex + i32.const 2 + i32.shl + i32.add + i32.load + local.get $value + i32.eq + if + local.get $fromIndex + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $fromIndex + i32.const 1 + i32.add + local.set $fromIndex + br $while-continue|0 + end + end + i32.const -1 + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $assembly/program.test/opcode (param $search i32) (result f64) + (local $idx i32) + (local $2 i32) + (local $3 f64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $assembly/instructions-exe/RUN + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $search + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#indexOf + local.set $idx + local.get $idx + i32.const 0 + i32.lt_s + if + i32.const 24080 + i32.const 24192 + i32.const 152 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $idx + f64.convert_i32_s + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value f64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 1888 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 3 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 3 + i32.shl + i32.add + local.get $value + f64.store + i32.const 0 + drop + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/program.test~anonymous|5 (param $$0 i32) (result i32) + (local $1 i32) + (local $code i32) + (local $3 i32) + (local $mask i32) + (local $basicBlocks i32) + (local $assert i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.const 3 + i32.const 39 + i32.const 0 + call $~lib/rt/__newArray + local.tee $1 + i32.store offset=4 + local.get $1 + i32.const 0 + global.get $assembly/instructions/misc/trap + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/program.test/opcode + call $~lib/array/Array#__set + local.get $1 + i32.const 1 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 2 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 3 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 4 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 5 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 6 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 7 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 8 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 9 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 10 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 11 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 12 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 13 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 14 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 15 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 16 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 17 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 18 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 19 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 20 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 21 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 22 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 23 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 24 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 25 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 26 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 27 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 28 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 29 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 30 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 31 + global.get $assembly/instructions/jump/jump_ind + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/program.test/opcode + call $~lib/array/Array#__set + local.get $1 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $assembly/program.test/u8arr + local.tee $code + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 4 + i32.const 3 + i32.const 39 + i32.const 24272 + call $~lib/rt/__newArray + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/program.test/u8arr + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + i32.const 32 + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $code + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $mask + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/program/BasicBlocks#constructor + local.tee $basicBlocks + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=24 + local.get $assert + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $mask + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=36 + local.get $7 + call $assembly/program/Mask#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + i32.const 24336 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=28 + local.get $7 + i32.const 4080 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=32 + local.get $7 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $basicBlocks + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=36 + local.get $7 + call $assembly/program/BasicBlocks#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + i32.const 24608 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=28 + local.get $7 + i32.const 4080 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=32 + local.get $7 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $start:assembly/program.test~anonymous|6 (param $$0 i32) (result i32) + (local $1 i32) + (local $jumpTable i32) + (local $assert i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 10 + i32.const 30 + i32.const 3 + i32.const 39 + i32.const 24880 + call $~lib/rt/__newArray + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/program.test/u8arr + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/program/JumpTable#constructor + local.tee $jumpTable + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $jumpTable + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=24 + local.get $4 + call $assembly/program/JumpTable#toString + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 25152 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + i32.const 4080 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + local.get $4 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/program.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + call $start:assembly/program + global.get $~lib/memory/__stack_pointer + i32.const 7 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 20752 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 21056 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 21088 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 21424 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 21456 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 21872 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + i32.const 21904 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 22048 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + i32.const 22080 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 23920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 5 + i32.const 23952 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 24736 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 6 + i32.const 24768 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 25360 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/program.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/array/Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/array/Array#get:dataStart + local.set $sourceStart + i32.const 0 + i32.eqz + drop + local.get $targetStart + local.get $sourceStart + local.get $sourceLen + i32.const 0 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/liftBytes (param $data i32) (result i32) + (local $p i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $p + i32.store offset=4 + local.get $p + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#set<~lib/array/Array> + local.get $p + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u24 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 3 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 3 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u16 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 2 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.const 15 + i32.and + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u32 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 4 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 3 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 4 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#isExhausted (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#get:offset + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $assembly/codec/Decoder#get:source + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + i32.ge_s + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $assembly/codec/Decoder#finish (param $this i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + i32.const 25696 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + call $assembly/codec/Decoder#get:source + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/codec/Decoder#get:offset + i32.sub + i32.const 10 + call $~lib/number/I32#toString + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/string/String#concat + i32.const 22672 + i32.const 31 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/MemoryBuilder#setEmpty (param $this i32) (param $access i32) (param $address i32) (param $len i32) (result i32) + (local $endAddress i32) + (local $currentAddress i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $address + local.get $len + i32.add + local.set $endAddress + local.get $address + local.set $currentAddress + loop $for-loop|0 + local.get $currentAddress + local.get $endAddress + i32.lt_u + if + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $access + local.get $currentAddress + call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress + drop + local.get $currentAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.add + local.set $currentAddress + br $for-loop|0 + end + end + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/spi/StandardProgram#constructor (param $this i32) (param $program i32) (param $memory i32) (param $registers i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 47 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:program + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:memory + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:registers + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:metadata + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/spi/StandardProgram#set:pc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i64.const 0 + call $assembly/spi/StandardProgram#set:gas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/spi/decodeSpi (param $data i32) (param $args i32) (result i32) + (local $argsLength i32) + (local $decoder i32) + (local $roLength i32) + (local $rwLength i32) + (local $heapPages i32) + (local $stackSize i32) + (local $roMem i32) + (local $rwMem i32) + (local $codeLength i32) + (local $code i32) + (local $program i32) + (local $builder i32) + (local $heapStart i32) + (local $heapZerosStart i32) + (local $heapZerosLength i32) + (local $heapZerosEnd i32) + (local $stackLength i32) + (local $stackStart i32) + (local $memory i32) + (local $registers i32) + (local $22 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + local.get $args + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $~lib/typedarray/Uint8Array#get:length + local.set $argsLength + local.get $argsLength + global.get $assembly/spi/DATA_LENGTH + i32.gt_u + if + i32.const 25552 + i32.const 25632 + i32.const 18 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#u24 + local.set $roLength + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#u24 + local.set $rwLength + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#u16 + local.set $heapPages + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#u24 + local.set $stackSize + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + local.get $roLength + call $assembly/codec/Decoder#bytes + local.tee $roMem + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + local.get $rwLength + call $assembly/codec/Decoder#bytes + local.tee $rwMem + i32.store offset=12 + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#u32 + local.set $codeLength + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + local.get $codeLength + call $assembly/codec/Decoder#bytes + local.tee $code + i32.store offset=16 + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#finish + global.get $~lib/memory/__stack_pointer + local.get $code + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/program/deblob + local.tee $program + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store offset=24 + i32.const 2 + global.get $assembly/memory-page/SEGMENT_SIZE + i32.mul + local.get $roLength + call $assembly/spi/alignToSegmentSize + i32.add + local.set $heapStart + local.get $heapStart + local.get $rwLength + call $assembly/spi/alignToPageSize + i32.add + local.set $heapZerosStart + local.get $heapPages + i32.const 65535 + i32.and + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.set $heapZerosLength + local.get $heapZerosStart + local.get $heapZerosLength + i32.add + local.set $heapZerosEnd + local.get $stackSize + call $assembly/spi/alignToPageSize + local.set $stackLength + global.get $assembly/spi/STACK_SEGMENT_END + local.get $stackLength + i32.sub + local.set $stackStart + local.get $roLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + global.get $assembly/memory-page/Access.Read + global.get $assembly/memory-page/SEGMENT_SIZE + local.get $roMem + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store offset=28 + local.get $22 + call $assembly/memory/MemoryBuilder#setData + drop + end + local.get $argsLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + global.get $assembly/memory-page/Access.Read + global.get $assembly/spi/ARGS_SEGMENT_START + local.get $args + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store offset=28 + local.get $22 + call $assembly/memory/MemoryBuilder#setData + drop + end + local.get $rwLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + global.get $assembly/memory-page/Access.Write + local.get $heapStart + local.get $rwMem + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store offset=28 + local.get $22 + call $assembly/memory/MemoryBuilder#setData + drop + end + local.get $heapZerosLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + global.get $assembly/memory-page/Access.Write + local.get $heapZerosStart + local.get $heapZerosLength + call $assembly/memory/MemoryBuilder#setEmpty + drop + end + local.get $stackLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + global.get $assembly/memory-page/Access.Write + local.get $stackStart + local.get $stackLength + call $assembly/memory/MemoryBuilder#setEmpty + drop + end + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + local.get $heapZerosEnd + call $assembly/memory/MemoryBuilder#build + local.tee $memory + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=36 + local.get $registers + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + i32.const 0 + i64.const 4294901760 + call $~lib/staticarray/StaticArray#__set + local.get $registers + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + i32.const 1 + global.get $assembly/spi/STACK_SEGMENT_END + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + local.get $registers + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + i32.const 7 + global.get $assembly/spi/ARGS_SEGMENT_START + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + local.get $registers + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + i32.const 8 + local.get $argsLength + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + i32.const 0 + local.get $program + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + local.get $memory + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store offset=28 + local.get $22 + local.get $registers + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store offset=40 + local.get $22 + call $assembly/spi/StandardProgram#constructor + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + ) + (func $assembly/program/Program#toString (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program/Program#get:code + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#toString + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program/Program#get:mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program/Mask#toString + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program/Program#get:jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program/JumpTable#toString + local.tee $3 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program/Program#get:basicBlocks + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program/BasicBlocks#toString + local.tee $4 + i32.store offset=20 + i32.const 26320 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + local.get $1 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26320 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 3 + local.get $2 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26320 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 5 + local.get $3 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26320 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 7 + local.get $4 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26320 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $"~lib/map/Map#get:size" (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $"~lib/map/Map#get:entriesCount" + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $value i64) + (local $sepLen i32) + (local $estLen i32) + (local $result i32) + (local $offset i32) + (local $value|9 i64) + (local $i i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 4080 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $lastIndex + i32.eqz + if + local.get $dataStart + i64.load + local.set $value + i32.const 0 + drop + i32.const 8 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 10 + call $~lib/util/number/utoa64 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $separator + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + local.set $sepLen + i32.const 20 + local.get $sepLen + i32.add + local.get $lastIndex + i32.mul + i32.const 20 + i32.add + local.set $estLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=4 + i32.const 0 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $lastIndex + i32.lt_s + if + local.get $dataStart + local.get $i + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $dataStart + local.get $lastIndex + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $estLen + local.get $offset + i32.gt_s + if + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.const 0 + local.get $offset + call $~lib/string/String#substring + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/staticarray/StaticArray#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 0 + drop + i32.const 1 + drop + local.get $this + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/staticarray/StaticArray#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/util/string/joinIntegerArray + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/staticarray/StaticArray#toString (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 10000 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/staticarray/StaticArray#join + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $assembly/spi/StandardProgram#toString (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/spi/StandardProgram#get:program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/program/Program#toString + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/spi/StandardProgram#get:memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Memory#get:pages + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $"~lib/map/Map#get:size" + i32.const 10 + call $~lib/number/I32#toString + local.tee $2 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/spi/StandardProgram#get:registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/staticarray/StaticArray#toString + local.tee $3 + i32.store offset=20 + i32.const 26048 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $1 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26048 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 3 + local.get $2 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26048 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 5 + local.get $3 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26048 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 4080 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/spi.test~anonymous|0 (param $$0 i32) (result i32) + (local $1 i32) + (local $PROGRAM i32) + (local $3 i32) + (local $ARGS i32) + (local $spi i32) + (local $assert i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 0 + i32.const 34 + i32.const 25472 + call $~lib/rt/__newArray + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $assembly/program/liftBytes + local.tee $PROGRAM + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 3 + i32.const 0 + i32.const 34 + i32.const 25520 + call $~lib/rt/__newArray + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $assembly/program/liftBytes + local.tee $ARGS + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $PROGRAM + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $ARGS + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/spi/decodeSpi + local.tee $spi + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=20 + local.get $assert + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $spi + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=32 + local.get $7 + call $assembly/spi/StandardProgram#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + i32.const 26384 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=24 + local.get $7 + i32.const 4080 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=28 + local.get $7 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $start:assembly/spi.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + call $start:assembly/spi + global.get $~lib/memory/__stack_pointer + i32.const 1 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 25392 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 26864 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/spi.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 21616 + i32.const 1888 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array<~lib/string/String>#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array<~lib/string/String>#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array<~lib/string/String>#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<~lib/string/String>#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 21616 + i32.const 1888 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/test-run/printSummary (param $msg i32) (param $okay i32) (param $total i32) + (local $ico i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $okay + local.get $total + i32.eq + if (result i32) + i32.const 27216 + else + i32.const 27248 + end + local.tee $ico + i32.store + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $4 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $okay + i32.const 10 + call $~lib/number/U32#toString + local.tee $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $total + i32.const 10 + call $~lib/number/U32#toString + local.tee $6 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $ico + local.tee $7 + i32.store offset=20 + i32.const 27344 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 0 + local.get $4 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27344 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 2 + local.get $5 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27344 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 4 + local.get $6 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27344 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 6 + local.get $7 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27344 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/test-run/run (param $tests i32) (param $file i32) (result i64) + (local $ok i32) + (local $i i32) + (local $res i32) + (local $5 i32) + (local $j i32) + (local $7 i32) + (local $8 i32) + (local $9 i64) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + i32.const 0 + local.set $ok + i32.const 26928 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $file + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/console/console.log + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/array/Array#get:length + i32.lt_s + if + i32.const 26960 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + local.get $i + call $~lib/array/Array#__get + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $assembly/test/Test#get:name + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + global.set $~argumentsLength + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + local.get $i + call $~lib/array/Array#__get + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/test/Test#get:ptr + i32.load + call_indirect (type $0) + local.tee $res + i32.store offset=20 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/test/Assert#get:isOkay + if + global.get $~lib/memory/__stack_pointer + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + local.get $i + call $~lib/array/Array#__get + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/test/Test#get:name + local.tee $5 + i32.store offset=24 + i32.const 27056 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 1 + local.get $5 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27056 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/console/console.log + local.get $ok + i32.const 1 + i32.add + local.set $ok + else + i32.const 0 + local.set $j + loop $for-loop|1 + local.get $j + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/test/Assert#get:errors + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/array/Array<~lib/string/String>#get:length + i32.lt_s + if + i32.const 27088 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $assembly/test/Assert#get:errors + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + local.get $j + call $~lib/array/Array<~lib/string/String>#__get + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/console/console.log + local.get $j + i32.const 1 + i32.add + local.set $j + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + local.get $i + call $~lib/array/Array#__get + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/test/Test#get:name + local.tee $7 + i32.store offset=28 + i32.const 27152 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 1 + local.get $7 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27152 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/console/console.log + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 27184 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $file + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $ok + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $~lib/array/Array#get:length + call $assembly/test-run/printSummary + local.get $ok + i64.extend_i32_s + i64.const 32 + i64.shl + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/array/Array#get:length + i64.extend_i32_s + i64.add + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $assembly/test-run/runAllTests + (local $a i64) + (local $okay i32) + (local $total i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i64.const 0 + local.set $a + local.get $a + global.get $assembly/instructions/bit.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 26896 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/instructions/branch.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27392 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/instructions/logic.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27440 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/instructions/math.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27488 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/memory.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27536 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/program.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27584 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/instructions/rot.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27632 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/spi.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27664 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + i64.const 32 + i64.shr_u + i32.wrap_i64 + local.set $okay + local.get $a + i32.wrap_i64 + local.set $total + i32.const 27696 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $okay + local.get $total + call $assembly/test-run/printSummary + local.get $okay + local.get $total + i32.ne + if + i32.const 27744 + i32.const 27808 + i32.const 28 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#__visit" (param $this i32) (param $cookie i32) + (local $entries i32) + (local $cur i32) + (local $end i32) + (local $entry i32) + (local $val i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:buckets" + local.get $cookie + call $~lib/rt/itcms/__visit + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:entries" + local.set $entries + i32.const 1 + drop + local.get $entries + local.set $cur + local.get $cur + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.6" + end + i32.mul + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + drop + i32.const 1 + drop + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $val + i32.const 0 + drop + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.7" + end + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $entries + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28u8%29=>u8>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28u8%29=>u8>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/object/Object#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 3 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1408 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 3 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 13 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/arraybuffer/ArrayBuffer#constructor (param $this i32) (param $length i32) (result i32) + (local $buffer i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.gt_u + if + i32.const 1296 + i32.const 1344 + i32.const 52 + i32.const 43 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $buffer + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/rt/__newArray (param $length i32) (param $alignLog2 i32) (param $id i32) (param $data i32) (result i32) + (local $bufferSize i32) + (local $buffer i32) + (local $array i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + local.get $alignLog2 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + local.get $data + call $~lib/rt/__newBuffer + local.tee $buffer + i32.store + i32.const 16 + local.get $id + call $~lib/rt/itcms/__new + local.set $array + local.get $array + local.get $buffer + i32.store + local.get $array + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + local.get $array + local.get $buffer + i32.store offset=4 + local.get $array + local.get $bufferSize + i32.store offset=8 + local.get $array + local.get $length + i32.store offset=12 + local.get $array + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $~lib/util/number/itoa32 (param $value i32) (param $radix i32) (result i32) + (local $sign i32) + (local $out i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|8 i32) + (local $buffer|9 i32) + (local $num|10 i32) + (local $offset|11 i32) + (local $val32 i32) + (local $decimals|13 i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 2304 + i32.const 2432 + i32.const 373 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i32.eqz + if + i32.const 2496 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $value + i32.const 31 + i32.shr_u + i32.const 1 + i32.shl + local.set $sign + local.get $sign + if + i32.const 0 + local.get $value + i32.sub + local.set $value + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer + local.get $value + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 31 + local.get $value + i32.clz + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|8 + global.get $~lib/memory/__stack_pointer + local.get $decimals|8 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|9 + local.get $value + local.set $num|10 + local.get $decimals|8 + local.set $offset|11 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|9 + local.get $num|10 + i64.extend_i32_u + local.get $offset|11 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.set $val32 + local.get $val32 + i64.extend_i32_u + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|13 + global.get $~lib/memory/__stack_pointer + local.get $decimals|13 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.get $val32 + i64.extend_i32_u + local.get $decimals|13 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $sign + if + local.get $out + i32.const 45 + i32.store16 + end + local.get $out + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + ) + (func $~lib/util/number/utoa64 (param $value i64) (param $radix i32) (result i32) + (local $out i32) + (local $val32 i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|8 i32) + (local $buffer|9 i32) + (local $num|10 i64) + (local $offset|11 i32) + (local $decimals|12 i32) + (local $buffer|13 i32) + (local $num|14 i64) + (local $offset|15 i32) + (local $decimals|16 i32) + (local $17 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 2304 + i32.const 2432 + i32.const 401 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i64.const 0 + i64.ne + i32.eqz + if + i32.const 2496 + local.set $17 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $17 + return + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + call $~lib/util/number/decimalCount64High + local.set $decimals|8 + global.get $~lib/memory/__stack_pointer + local.get $decimals|8 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|9 + local.get $value + local.set $num|10 + local.get $decimals|8 + local.set $offset|11 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|9 + local.get $num|10 + local.get $offset|11 + call $~lib/util/number/utoa64_dec_lut + end + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 63 + local.get $value + i64.clz + i32.wrap_i64 + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|12 + global.get $~lib/memory/__stack_pointer + local.get $decimals|12 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|13 + local.get $value + local.set $num|14 + local.get $decimals|12 + local.set $offset|15 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|13 + local.get $num|14 + local.get $offset|15 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|16 + global.get $~lib/memory/__stack_pointer + local.get $decimals|16 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $value + local.get $decimals|16 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $out + local.set $17 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $17 + return + ) + (func $~lib/util/number/itoa64 (param $value i64) (param $radix i32) (result i32) + (local $sign i32) + (local $out i32) + (local $val32 i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|9 i32) + (local $buffer|10 i32) + (local $num|11 i64) + (local $offset|12 i32) + (local $decimals|13 i32) + (local $buffer|14 i32) + (local $num|15 i64) + (local $offset|16 i32) + (local $decimals|17 i32) + (local $18 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 2304 + i32.const 2432 + i32.const 431 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i64.const 0 + i64.ne + i32.eqz + if + i32.const 2496 + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + end + local.get $value + i64.const 63 + i64.shr_u + i32.wrap_i64 + i32.const 1 + i32.shl + local.set $sign + local.get $sign + if + i64.const 0 + local.get $value + i64.sub + local.set $value + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + call $~lib/util/number/decimalCount64High + local.set $decimals|9 + global.get $~lib/memory/__stack_pointer + local.get $decimals|9 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|10 + local.get $value + local.set $num|11 + local.get $decimals|9 + local.set $offset|12 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|10 + local.get $num|11 + local.get $offset|12 + call $~lib/util/number/utoa64_dec_lut + end + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 63 + local.get $value + i64.clz + i32.wrap_i64 + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|13 + global.get $~lib/memory/__stack_pointer + local.get $decimals|13 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|14 + local.get $value + local.set $num|15 + local.get $decimals|13 + local.set $offset|16 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|14 + local.get $num|15 + local.get $offset|16 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|17 + global.get $~lib/memory/__stack_pointer + local.get $decimals|17 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.get $value + local.get $decimals|17 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $sign + if + local.get $out + i32.const 45 + i32.store16 + end + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + ) + (func $~lib/util/number/utoa32 (param $value i32) (param $radix i32) (result i32) + (local $out i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|7 i32) + (local $buffer|8 i32) + (local $num|9 i32) + (local $offset|10 i32) + (local $decimals|11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 2304 + i32.const 2432 + i32.const 350 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i32.eqz + if + i32.const 2496 + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer + local.get $value + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 31 + local.get $value + i32.clz + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|7 + global.get $~lib/memory/__stack_pointer + local.get $decimals|7 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|8 + local.get $value + local.set $num|9 + local.get $decimals|7 + local.set $offset|10 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|8 + local.get $num|9 + i64.extend_i32_u + local.get $offset|10 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + i64.extend_i32_u + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|11 + global.get $~lib/memory/__stack_pointer + local.get $decimals|11 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $value + i64.extend_i32_u + local.get $decimals|11 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $out + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 0 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1408 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 0 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 29 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1408 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 2 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 38 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1408 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 2 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 44 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) +) From 8c77ac22dcd6525665521ff4abcf2892a9de0047 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Mon, 13 Oct 2025 18:46:28 +0200 Subject: [PATCH 02/21] upload build --- build/.gitignore | 1 - build/debug.d.ts | 182 + build/debug.js | 372 + build/debug.wasm | Bin 0 -> 186138 bytes build/debug.wasm.map | 1 + build/debug.wat | 45256 ++++++++++++++++++++++++++++++++++++++ build/release.d.ts | 182 + build/release.js | 372 + build/release.wasm | Bin 0 -> 93361 bytes build/release.wasm.map | 1 + build/release.wat | 36780 +++++++++++++++++++++++++++++++ build/test.d.ts | 6 + build/test.js | 47 + build/test.wasm | Bin 0 -> 189597 bytes build/test.wasm.map | 1 + build/test.wat | 45369 +++++++++++++++++++++++++++++++++++++++ 16 files changed, 128569 insertions(+), 1 deletion(-) create mode 100644 build/debug.d.ts create mode 100644 build/debug.js create mode 100644 build/debug.wasm create mode 100644 build/debug.wasm.map create mode 100644 build/debug.wat create mode 100644 build/release.d.ts create mode 100644 build/release.js create mode 100644 build/release.wasm create mode 100644 build/release.wasm.map create mode 100644 build/release.wat create mode 100644 build/test.d.ts create mode 100644 build/test.js create mode 100644 build/test.wasm create mode 100644 build/test.wasm.map create mode 100644 build/test.wat diff --git a/build/.gitignore b/build/.gitignore index d6b7ef3..f935021 100644 --- a/build/.gitignore +++ b/build/.gitignore @@ -1,2 +1 @@ -* !.gitignore diff --git a/build/debug.d.ts b/build/debug.d.ts new file mode 100644 index 0000000..97c330c --- /dev/null +++ b/build/debug.d.ts @@ -0,0 +1,182 @@ +/** Exported memory */ +export declare const memory: WebAssembly.Memory; +/** assembly/index/InputKind */ +export declare enum InputKind { + /** @type `i32` */ + Generic, + /** @type `i32` */ + SPI, +} +/** assembly/index/HasMetadata */ +export declare enum HasMetadata { + /** @type `i32` */ + Yes, + /** @type `i32` */ + No, +} +/** + * assembly/index/disassemble + * @param input `~lib/array/Array` + * @param kind `i32` + * @param withMetadata `i32` + * @returns `~lib/string/String` + */ +export declare function disassemble(input: Array, kind: number, withMetadata: number): string; +/** + * assembly/index/runProgram + * @param input `~lib/array/Array` + * @param registers `~lib/array/Array` + * @param kind `i32` + * @returns `assembly/api-generic/VmOutput` + */ +export declare function runProgram(input: Array, registers: Array, kind: number): __Record44; +/** + * assembly/api-generic/runVm + * @param input `assembly/api-generic/VmInput` + * @param logs `bool` + * @param useSbrkGas `bool` + * @returns `assembly/api-generic/VmOutput` + */ +export declare function runVm(input: __Record47, logs?: boolean, useSbrkGas?: boolean): __Record44; +/** + * assembly/api-generic/getAssembly + * @param p `assembly/program/Program` + * @returns `~lib/string/String` + */ +export declare function getAssembly(p: __Internref30): string; +/** + * assembly/program-build/wrapAsProgram + * @param bytecode `~lib/typedarray/Uint8Array` + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array; +/** + * assembly/api/resetGeneric + * @param program `~lib/array/Array` + * @param flatRegisters `~lib/array/Array` + * @param initialGas `i64` + */ +export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint): void; +/** + * assembly/api/resetGenericWithMemory + * @param program `~lib/array/Array` + * @param flatRegisters `~lib/array/Array` + * @param pageMap `~lib/typedarray/Uint8Array` + * @param chunks `~lib/typedarray/Uint8Array` + * @param initialGas `i64` + */ +export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint): void; +/** + * assembly/api/nextStep + * @returns `bool` + */ +export declare function nextStep(): boolean; +/** + * assembly/api/nSteps + * @param steps `u32` + * @returns `bool` + */ +export declare function nSteps(steps: number): boolean; +/** + * assembly/api/getProgramCounter + * @returns `u32` + */ +export declare function getProgramCounter(): number; +/** + * assembly/api/setNextProgramCounter + * @param pc `u32` + */ +export declare function setNextProgramCounter(pc: number): void; +/** + * assembly/api/getStatus + * @returns `u8` + */ +export declare function getStatus(): number; +/** + * assembly/api/getExitArg + * @returns `u32` + */ +export declare function getExitArg(): number; +/** + * assembly/api/getGasLeft + * @returns `i64` + */ +export declare function getGasLeft(): bigint; +/** + * assembly/api/setGasLeft + * @param gas `i64` + */ +export declare function setGasLeft(gas: bigint): void; +/** + * assembly/api/getRegisters + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function getRegisters(): Uint8Array; +/** + * assembly/api/setRegisters + * @param flatRegisters `~lib/array/Array` + */ +export declare function setRegisters(flatRegisters: Array): void; +/** + * assembly/api/getPageDump + * @param index `u32` + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function getPageDump(index: number): Uint8Array; +/** + * assembly/api/setMemory + * @param address `u32` + * @param data `~lib/typedarray/Uint8Array` + */ +export declare function setMemory(address: number, data: Uint8Array): void; +/** assembly/api-generic/InitialChunk */ +declare interface __Record45 { + /** @type `u32` */ + address: number | TOmittable; + /** @type `~lib/array/Array` */ + data: Array; +} +/** assembly/api-generic/VmOutput */ +declare interface __Record44 { + /** @type `i32` */ + status: number | TOmittable; + /** @type `~lib/array/Array` */ + registers: Array; + /** @type `u32` */ + pc: number | TOmittable; + /** @type `~lib/array/Array` */ + memory: Array<__Record45>; + /** @type `i64` */ + gas: bigint | TOmittable; + /** @type `u32` */ + exitCode: number | TOmittable; +} +/** assembly/api-generic/InitialPage */ +declare interface __Record48 { + /** @type `u32` */ + address: number | TOmittable; + /** @type `u32` */ + length: number | TOmittable; + /** @type `i32` */ + access: number | TOmittable; +} +/** assembly/api-generic/VmInput */ +declare interface __Record47 { + /** @type `~lib/array/Array` */ + registers: Array; + /** @type `u32` */ + pc: number | TOmittable; + /** @type `i64` */ + gas: bigint | TOmittable; + /** @type `~lib/array/Array` */ + program: Array; + /** @type `~lib/array/Array` */ + pageMap: Array<__Record48>; + /** @type `~lib/array/Array` */ + memory: Array<__Record45>; +} +/** assembly/program/Program */ +declare class __Internref30 extends Number { + private __nominal30: symbol; + private __nominal0: symbol; +} diff --git a/build/debug.js b/build/debug.js new file mode 100644 index 0000000..1fc85df --- /dev/null +++ b/build/debug.js @@ -0,0 +1,372 @@ +async function instantiate(module, imports = {}) { + const adaptedImports = { + env: Object.setPrototypeOf({ + abort(message, fileName, lineNumber, columnNumber) { + // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void + message = __liftString(message >>> 0); + fileName = __liftString(fileName >>> 0); + lineNumber = lineNumber >>> 0; + columnNumber = columnNumber >>> 0; + (() => { + // @external.js + throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); + })(); + }, + "console.log"(text) { + // ~lib/bindings/dom/console.log(~lib/string/String) => void + text = __liftString(text >>> 0); + console.log(text); + }, + }, Object.assign(Object.create(globalThis), imports.env || {})), + }; + const { exports } = await WebAssembly.instantiate(module, adaptedImports); + const memory = exports.memory || imports.env.memory; + const adaptedExports = Object.setPrototypeOf({ + InputKind: (values => ( + // assembly/index/InputKind + values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", + values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", + values + ))({}), + HasMetadata: (values => ( + // assembly/index/HasMetadata + values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", + values[values.No = exports["HasMetadata.No"].valueOf()] = "No", + values + ))({}), + disassemble(input, kind, withMetadata) { + // assembly/index/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String + input = __lowerArray(__setU8, 27, 0, input) || __notnull(); + return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); + }, + runProgram(input, registers, kind) { + // assembly/index/runProgram(~lib/array/Array, ~lib/array/Array, i32) => assembly/api-generic/VmOutput + input = __retain(__lowerArray(__setU8, 27, 0, input) || __notnull()); + registers = __lowerArray(__setU64, 43, 3, registers) || __notnull(); + try { + return __liftRecord44(exports.runProgram(input, registers, kind) >>> 0); + } finally { + __release(input); + } + }, + runVm(input, logs, useSbrkGas) { + // assembly/api-generic/runVm(assembly/api-generic/VmInput, bool?, bool?) => assembly/api-generic/VmOutput + input = __lowerRecord47(input) || __notnull(); + logs = logs ? 1 : 0; + useSbrkGas = useSbrkGas ? 1 : 0; + exports.__setArgumentsLength(arguments.length); + return __liftRecord44(exports.runVm(input, logs, useSbrkGas) >>> 0); + }, + getAssembly(p) { + // assembly/api-generic/getAssembly(assembly/program/Program) => ~lib/string/String + p = __lowerInternref(p) || __notnull(); + return __liftString(exports.getAssembly(p) >>> 0); + }, + wrapAsProgram(bytecode) { + // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array + bytecode = __lowerTypedArray(Uint8Array, 5, 0, bytecode) || __notnull(); + return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0); + }, + resetGeneric(program, flatRegisters, initialGas) { + // assembly/api/resetGeneric(~lib/array/Array, ~lib/array/Array, i64) => void + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); + initialGas = initialGas || 0n; + try { + exports.resetGeneric(program, flatRegisters, initialGas); + } finally { + __release(program); + } + }, + resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas) { + // assembly/api/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64) => void + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + flatRegisters = __retain(__lowerArray(__setU8, 27, 0, flatRegisters) || __notnull()); + pageMap = __retain(__lowerTypedArray(Uint8Array, 5, 0, pageMap) || __notnull()); + chunks = __lowerTypedArray(Uint8Array, 5, 0, chunks) || __notnull(); + initialGas = initialGas || 0n; + try { + exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas); + } finally { + __release(program); + __release(flatRegisters); + __release(pageMap); + } + }, + nextStep() { + // assembly/api/nextStep() => bool + return exports.nextStep() != 0; + }, + nSteps(steps) { + // assembly/api/nSteps(u32) => bool + return exports.nSteps(steps) != 0; + }, + getProgramCounter() { + // assembly/api/getProgramCounter() => u32 + return exports.getProgramCounter() >>> 0; + }, + getExitArg() { + // assembly/api/getExitArg() => u32 + return exports.getExitArg() >>> 0; + }, + setGasLeft(gas) { + // assembly/api/setGasLeft(i64) => void + gas = gas || 0n; + exports.setGasLeft(gas); + }, + getRegisters() { + // assembly/api/getRegisters() => ~lib/typedarray/Uint8Array + return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); + }, + setRegisters(flatRegisters) { + // assembly/api/setRegisters(~lib/array/Array) => void + flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); + exports.setRegisters(flatRegisters); + }, + getPageDump(index) { + // assembly/api/getPageDump(u32) => ~lib/typedarray/Uint8Array + return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); + }, + setMemory(address, data) { + // assembly/api/setMemory(u32, ~lib/typedarray/Uint8Array) => void + data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); + exports.setMemory(address, data); + }, + }, exports); + function __liftRecord45(pointer) { + // assembly/api-generic/InitialChunk + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + address: __getU32(pointer + 0), + data: __liftArray(__getU8, 0, __getU32(pointer + 4)), + }; + } + function __liftRecord44(pointer) { + // assembly/api-generic/VmOutput + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + status: __getI32(pointer + 0), + registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), + pc: __getU32(pointer + 8), + memory: __liftArray(pointer => __liftRecord45(__getU32(pointer)), 2, __getU32(pointer + 12)), + gas: __getI64(pointer + 16), + exitCode: __getU32(pointer + 24), + }; + } + function __lowerRecord48(value) { + // assembly/api-generic/InitialPage + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(12, 48)); + __setU32(pointer + 0, value.address); + __setU32(pointer + 4, value.length); + __setU32(pointer + 8, value.access); + exports.__unpin(pointer); + return pointer; + } + function __lowerRecord45(value) { + // assembly/api-generic/InitialChunk + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(8, 45)); + __setU32(pointer + 0, value.address); + __setU32(pointer + 4, __lowerArray(__setU8, 27, 0, value.data) || __notnull()); + exports.__unpin(pointer); + return pointer; + } + function __lowerRecord47(value) { + // assembly/api-generic/VmInput + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(28, 47)); + __setU32(pointer + 0, __lowerArray(__setU64, 43, 3, value.registers) || __notnull()); + __setU32(pointer + 4, value.pc); + __setU64(pointer + 8, value.gas || 0n); + __setU32(pointer + 16, __lowerArray(__setU8, 27, 0, value.program) || __notnull()); + __setU32(pointer + 20, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, value.pageMap) || __notnull()); + __setU32(pointer + 24, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord45(value) || __notnull()); }, 46, 2, value.memory) || __notnull()); + exports.__unpin(pointer); + return pointer; + } + function __liftString(pointer) { + if (!pointer) return null; + const + end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, + memoryU16 = new Uint16Array(memory.buffer); + let + start = pointer >>> 1, + string = ""; + while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); + return string + String.fromCharCode(...memoryU16.subarray(start, end)); + } + function __liftArray(liftElement, align, pointer) { + if (!pointer) return null; + const + dataStart = __getU32(pointer + 4), + length = __dataview.getUint32(pointer + 12, true), + values = new Array(length); + for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0)); + return values; + } + function __lowerArray(lowerElement, id, align, values) { + if (values == null) return 0; + const + length = values.length, + buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, + header = exports.__pin(exports.__new(16, id)) >>> 0; + __setU32(header + 0, buffer); + __dataview.setUint32(header + 4, buffer, true); + __dataview.setUint32(header + 8, length << align, true); + __dataview.setUint32(header + 12, length, true); + for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]); + exports.__unpin(buffer); + exports.__unpin(header); + return header; + } + function __liftTypedArray(constructor, pointer) { + if (!pointer) return null; + return new constructor( + memory.buffer, + __getU32(pointer + 4), + __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT + ).slice(); + } + function __lowerTypedArray(constructor, id, align, values) { + if (values == null) return 0; + const + length = values.length, + buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, + header = exports.__new(12, id) >>> 0; + __setU32(header + 0, buffer); + __dataview.setUint32(header + 4, buffer, true); + __dataview.setUint32(header + 8, length << align, true); + new constructor(memory.buffer, buffer, length).set(values); + exports.__unpin(buffer); + return header; + } + class Internref extends Number {} + function __lowerInternref(value) { + if (value == null) return 0; + if (value instanceof Internref) return value.valueOf(); + throw TypeError("internref expected"); + } + const refcounts = new Map(); + function __retain(pointer) { + if (pointer) { + const refcount = refcounts.get(pointer); + if (refcount) refcounts.set(pointer, refcount + 1); + else refcounts.set(exports.__pin(pointer), 1); + } + return pointer; + } + function __release(pointer) { + if (pointer) { + const refcount = refcounts.get(pointer); + if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer); + else if (refcount) refcounts.set(pointer, refcount - 1); + else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`); + } + } + function __notnull() { + throw TypeError("value must not be null"); + } + let __dataview = new DataView(memory.buffer); + function __setU8(pointer, value) { + try { + __dataview.setUint8(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setUint8(pointer, value, true); + } + } + function __setU32(pointer, value) { + try { + __dataview.setUint32(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setUint32(pointer, value, true); + } + } + function __setU64(pointer, value) { + try { + __dataview.setBigUint64(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setBigUint64(pointer, value, true); + } + } + function __getU8(pointer) { + try { + return __dataview.getUint8(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getUint8(pointer, true); + } + } + function __getI32(pointer) { + try { + return __dataview.getInt32(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getInt32(pointer, true); + } + } + function __getU32(pointer) { + try { + return __dataview.getUint32(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getUint32(pointer, true); + } + } + function __getI64(pointer) { + try { + return __dataview.getBigInt64(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getBigInt64(pointer, true); + } + } + function __getU64(pointer) { + try { + return __dataview.getBigUint64(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getBigUint64(pointer, true); + } + } + return adaptedExports; +} +export const { + memory, + InputKind, + HasMetadata, + disassemble, + runProgram, + runVm, + getAssembly, + wrapAsProgram, + resetGeneric, + resetGenericWithMemory, + nextStep, + nSteps, + getProgramCounter, + setNextProgramCounter, + getStatus, + getExitArg, + getGasLeft, + setGasLeft, + getRegisters, + setRegisters, + getPageDump, + setMemory, +} = await (async url => instantiate( + await (async () => { + const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); + if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } + else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } + })(), { + } +))(new URL("debug.wasm", import.meta.url)); diff --git a/build/debug.wasm b/build/debug.wasm new file mode 100644 index 0000000000000000000000000000000000000000..3e089c857ddf44378c128c5cd641ae7fb6f281ee GIT binary patch literal 186138 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 aTef8Wlxa;psjlI^X{(a?!D)lZq5lJAL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/0a78010a7801?v=0.6.4 **/\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT = 12;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/24ee0024ee00?v=0.6.4 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const pageIdx = u32(currentAddress >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n const relAddress = currentAddress % PAGE_SIZE;\n const page = this.pages.get(pageIdx);\n const spaceInPage = PAGE_SIZE - relAddress;\n\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** https://graypaper.fluffylabs.dev/#/9a08063/2cc5022cc502?v=0.6.6 */\nexport function decodeSpi(data: Uint8Array): Program {\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const _heapPages = decoder.u16();\n const _stackSize = decoder.u24();\n\n const _roMem = decoder.bytes(roLength);\n const _rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n return deblob(code);\n}\n\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { RUN } from \"./instructions-exe\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, JumpTable, Program, ProgramCounter, decodeArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { InitialChunk, InitialPage, buildMemory } from \"./api-generic\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { VmInput, VmOutput, getAssembly, runVm } from \"./api-generic\";\nimport { deblob, decodeSpi, extractCodeAndMetadata, liftBytes } from \"./program\";\n\nexport * from \"./api\";\nexport { runVm, getAssembly } from \"./api-generic\";\nexport { wrapAsProgram } from \"./program-build\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n let program = liftBytes(input);\n let output = \"\";\n\n if (withMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(program);\n program = data.code;\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += data.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n if (kind === InputKind.Generic) {\n const p = deblob(program);\n return output + getAssembly(p);\n }\n\n if (kind === InputKind.SPI) {\n const p = decodeSpi(program);\n return output + getAssembly(p);\n }\n\n return `Unknown kind: ${kind}`;\n}\n\nexport function runProgram(input: u8[], registers: u64[], kind: InputKind): VmOutput {\n if (kind === InputKind.Generic) {\n const vmInput = new VmInput();\n vmInput.registers = registers;\n vmInput.gas = 10_000;\n vmInput.program = input;\n\n const output = runVm(vmInput, true);\n console.log(`Finished with status: ${output.status}`);\n return output;\n }\n\n if (kind === InputKind.SPI) {\n throw new Error(\"SPI running not supported yet\");\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { Program, deblob, decodeArguments, liftBytes, resolveArguments } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n registers: u64[] = new Array(NO_OF_REGISTERS).fill(0);\n pc: u32 = 0;\n gas: i64 = 0;\n program: u8[] = [];\n pageMap: InitialPage[] = [];\n memory: InitialChunk[] = [];\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const p = deblob(liftBytes(input.program));\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < registers.length; r++) {\n registers[r] = input.registers[r];\n }\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, input.pageMap, input.memory);\n\n const int = new Interpreter(p, registers, memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = p.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n return this.gas < 0;\n }\n}\n","import { Arguments, REQUIRED_BYTES, nibbles } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/debug.wat b/build/debug.wat new file mode 100644 index 0000000..cfbba47 --- /dev/null +++ b/build/debug.wat @@ -0,0 +1,45256 @@ +(module + (type $0 (func (param i32) (result i32))) + (type $1 (func (param i32 i32))) + (type $2 (func (param i32 i32 i32) (result i32))) + (type $3 (func (param i32 i32) (result i32))) + (type $4 (func (param i32 i32 i32))) + (type $5 (func (param i32 i32 i32 i32) (result i32))) + (type $6 (func (param i32))) + (type $7 (func)) + (type $8 (func (param i32) (result i64))) + (type $9 (func (param i32 i64))) + (type $10 (func (result i32))) + (type $11 (func (param i64 i64) (result i64))) + (type $12 (func (param i64 i32) (result i32))) + (type $13 (func (param i32 i64) (result i32))) + (type $14 (func (param i64) (result i32))) + (type $15 (func (param i32 i32 i64))) + (type $16 (func (param i32 i32 i32 i32))) + (type $17 (func (param i64 i32 i32) (result i32))) + (type $18 (func (param i32 i32 i64) (result i32))) + (type $19 (func (param i32 i64 i32))) + (type $20 (func (param i32 i32) (result i64))) + (type $21 (func (param i32 i64 i32 i32) (result i32))) + (type $22 (func (param i32 i32 i32 i32 i64))) + (type $23 (func (param i32 i32 i64 i32) (result i32))) + (type $24 (func (param i64) (result i64))) + (type $25 (func (param i32 i32 i32 i32 i32))) + (type $26 (func (param i32 i64 i32 i32))) + (type $27 (func (param i32 i32 i64 i32 i32))) + (type $28 (func (param i32 i32 i32 i32 i32) (result i32))) + (type $29 (func (param i32 i32 i64 i32))) + (type $30 (func (result i64))) + (type $31 (func (param i64))) + (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) + (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) + (global $assembly/arguments/Arguments.Zero i32 (i32.const 0)) + (global $assembly/arguments/Arguments.OneImm i32 (i32.const 1)) + (global $assembly/arguments/Arguments.TwoImm i32 (i32.const 2)) + (global $assembly/arguments/Arguments.OneOff i32 (i32.const 3)) + (global $assembly/arguments/Arguments.OneRegOneImm i32 (i32.const 4)) + (global $assembly/arguments/Arguments.OneRegOneExtImm i32 (i32.const 5)) + (global $assembly/arguments/Arguments.OneRegTwoImm i32 (i32.const 6)) + (global $assembly/arguments/Arguments.OneRegOneImmOneOff i32 (i32.const 7)) + (global $assembly/arguments/Arguments.TwoReg i32 (i32.const 8)) + (global $assembly/arguments/Arguments.TwoRegOneImm i32 (i32.const 9)) + (global $assembly/arguments/Arguments.TwoRegOneOff i32 (i32.const 10)) + (global $assembly/arguments/Arguments.TwoRegTwoImm i32 (i32.const 11)) + (global $assembly/arguments/Arguments.ThreeReg i32 (i32.const 12)) + (global $assembly/arguments/RELEVANT_ARGS i32 (i32.const 112)) + (global $assembly/arguments/REQUIRED_BYTES i32 (i32.const 240)) + (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) + (global $~lib/shared/runtime/Runtime.Stub i32 (i32.const 0)) + (global $~lib/shared/runtime/Runtime.Minimal i32 (i32.const 1)) + (global $~lib/shared/runtime/Runtime.Incremental i32 (i32.const 2)) + (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) + (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) + (global $~lib/native/ASC_LOW_MEMORY_LIMIT i32 (i32.const 0)) + (global $~lib/builtins/i32.MAX_VALUE i32 (i32.const 2147483647)) + (global $~argumentsLength (mut i32) (i32.const 0)) + (global $assembly/arguments/DECODERS i32 (i32.const 1248)) + (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) + (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) + (global $~lib/native/ASC_RUNTIME i32 (i32.const 2)) + (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) + (global $assembly/registers/NO_OF_REGISTERS i32 (i32.const 13)) + (global $assembly/registers/REG_SIZE_BYTES i32 (i32.const 8)) + (global $assembly/memory-page/PAGE_SIZE i32 (i32.const 4096)) + (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) + (global $~lib/native/ASC_SHRINK_LEVEL i32 (i32.const 0)) + (global $assembly/memory-page/RESERVED_MEMORY (mut i32) (i32.const 0)) + (global $assembly/memory-page/RESERVED_PAGES (mut i32) (i32.const 0)) + (global $assembly/memory-page/ALLOCATE_EAGERLY (mut i32) (i32.const 0)) + (global $assembly/memory-page/Access.None i32 (i32.const 0)) + (global $assembly/memory-page/Access.Read i32 (i32.const 1)) + (global $assembly/memory-page/Access.Write i32 (i32.const 2)) + (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) + (global $assembly/memory/MEMORY_SIZE i64 (i64.const 4294967296)) + (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) + (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) + (global $assembly/instructions/outcome/Result.PANIC i32 (i32.const 0)) + (global $assembly/instructions/outcome/Result.FAULT i32 (i32.const 1)) + (global $assembly/instructions/outcome/Result.FAULT_ACCESS i32 (i32.const 2)) + (global $assembly/instructions/outcome/Result.HOST i32 (i32.const 3)) + (global $assembly/instructions/outcome/Outcome.Ok i32 (i32.const 0)) + (global $assembly/instructions/outcome/Outcome.StaticJump i32 (i32.const 1)) + (global $assembly/instructions/outcome/Outcome.DynamicJump i32 (i32.const 2)) + (global $assembly/instructions/outcome/Outcome.Result i32 (i32.const 3)) + (global $assembly/instructions/bit/count_set_bits_64 i32 (i32.const 8352)) + (global $assembly/instructions/bit/count_set_bits_32 i32 (i32.const 8384)) + (global $assembly/instructions/bit/leading_zero_bits_64 i32 (i32.const 8416)) + (global $assembly/instructions/bit/leading_zero_bits_32 i32 (i32.const 8448)) + (global $assembly/instructions/bit/trailing_zero_bits_64 i32 (i32.const 8480)) + (global $assembly/instructions/bit/trailing_zero_bits_32 i32 (i32.const 8512)) + (global $assembly/instructions/bit/sign_extend_8 i32 (i32.const 8544)) + (global $assembly/instructions/bit/sign_extend_16 i32 (i32.const 8576)) + (global $assembly/instructions/bit/zero_extend_16 i32 (i32.const 8608)) + (global $assembly/instructions/bit/reverse_bytes i32 (i32.const 8640)) + (global $assembly/instructions/branch/branch_eq_imm i32 (i32.const 8672)) + (global $assembly/instructions/branch/branch_ne_imm i32 (i32.const 8704)) + (global $assembly/instructions/branch/branch_lt_u_imm i32 (i32.const 8736)) + (global $assembly/instructions/branch/branch_le_u_imm i32 (i32.const 8768)) + (global $assembly/instructions/branch/branch_ge_u_imm i32 (i32.const 8800)) + (global $assembly/instructions/branch/branch_gt_u_imm i32 (i32.const 8832)) + (global $assembly/instructions/branch/branch_lt_s_imm i32 (i32.const 8864)) + (global $assembly/instructions/branch/branch_le_s_imm i32 (i32.const 8896)) + (global $assembly/instructions/branch/branch_ge_s_imm i32 (i32.const 8928)) + (global $assembly/instructions/branch/branch_gt_s_imm i32 (i32.const 8960)) + (global $assembly/instructions/branch/branch_eq i32 (i32.const 8992)) + (global $assembly/instructions/branch/branch_ne i32 (i32.const 9024)) + (global $assembly/instructions/branch/branch_lt_u i32 (i32.const 9056)) + (global $assembly/instructions/branch/branch_lt_s i32 (i32.const 9088)) + (global $assembly/instructions/branch/branch_ge_u i32 (i32.const 9120)) + (global $assembly/instructions/branch/branch_ge_s i32 (i32.const 9152)) + (global $assembly/instructions/jump/jump i32 (i32.const 9184)) + (global $assembly/instructions/jump/jump_ind i32 (i32.const 9216)) + (global $assembly/instructions/jump/load_imm_jump i32 (i32.const 9248)) + (global $assembly/instructions/jump/load_imm_jump_ind i32 (i32.const 9280)) + (global $assembly/instructions/load/load_imm_64 i32 (i32.const 9312)) + (global $assembly/instructions/load/load_imm i32 (i32.const 9344)) + (global $assembly/instructions/load/load_u8 i32 (i32.const 9696)) + (global $assembly/instructions/load/load_i8 i32 (i32.const 9728)) + (global $assembly/instructions/load/load_u16 i32 (i32.const 9760)) + (global $assembly/instructions/load/load_i16 i32 (i32.const 9792)) + (global $assembly/instructions/load/load_u32 i32 (i32.const 9824)) + (global $assembly/instructions/load/load_i32 i32 (i32.const 9856)) + (global $assembly/instructions/load/load_u64 i32 (i32.const 9888)) + (global $assembly/instructions/load/load_ind_u8 i32 (i32.const 9920)) + (global $assembly/instructions/load/load_ind_i8 i32 (i32.const 9952)) + (global $assembly/instructions/load/load_ind_u16 i32 (i32.const 9984)) + (global $assembly/instructions/load/load_ind_i16 i32 (i32.const 10016)) + (global $assembly/instructions/load/load_ind_u32 i32 (i32.const 10048)) + (global $assembly/instructions/load/load_ind_i32 i32 (i32.const 10080)) + (global $assembly/instructions/load/load_ind_u64 i32 (i32.const 10112)) + (global $assembly/instructions/logic/and_imm i32 (i32.const 10144)) + (global $assembly/instructions/logic/xor_imm i32 (i32.const 10176)) + (global $assembly/instructions/logic/or_imm i32 (i32.const 10208)) + (global $assembly/instructions/logic/and i32 (i32.const 10240)) + (global $assembly/instructions/logic/xor i32 (i32.const 10272)) + (global $assembly/instructions/logic/or i32 (i32.const 10304)) + (global $assembly/instructions/logic/and_inv i32 (i32.const 10336)) + (global $assembly/instructions/logic/or_inv i32 (i32.const 10368)) + (global $assembly/instructions/logic/xnor i32 (i32.const 10400)) + (global $assembly/instructions/math/add_imm_32 i32 (i32.const 10432)) + (global $assembly/instructions/math/mul_imm_32 i32 (i32.const 10464)) + (global $assembly/instructions/math/neg_add_imm_32 i32 (i32.const 10496)) + (global $assembly/instructions/math/add_imm i32 (i32.const 10528)) + (global $assembly/instructions/math/mul_imm i32 (i32.const 10560)) + (global $assembly/instructions/math/neg_add_imm i32 (i32.const 10592)) + (global $assembly/instructions/math/add_32 i32 (i32.const 10624)) + (global $assembly/instructions/math/sub_32 i32 (i32.const 10656)) + (global $assembly/instructions/math/mul_32 i32 (i32.const 10688)) + (global $~lib/builtins/u64.MAX_VALUE i64 (i64.const -1)) + (global $assembly/instructions/math/div_u_32 i32 (i32.const 10720)) + (global $~lib/builtins/i32.MIN_VALUE i32 (i32.const -2147483648)) + (global $assembly/instructions/math/div_s_32 i32 (i32.const 10752)) + (global $assembly/instructions/math/rem_u_32 i32 (i32.const 10784)) + (global $assembly/instructions/math/rem_s_32 i32 (i32.const 10816)) + (global $assembly/instructions/math/add_64 i32 (i32.const 10848)) + (global $assembly/instructions/math/sub i32 (i32.const 10880)) + (global $assembly/instructions/math/mul i32 (i32.const 10912)) + (global $assembly/instructions/math/div_u i32 (i32.const 10944)) + (global $~lib/builtins/i64.MIN_VALUE i64 (i64.const -9223372036854775808)) + (global $assembly/instructions/math/div_s i32 (i32.const 10976)) + (global $assembly/instructions/math/rem_u i32 (i32.const 11008)) + (global $assembly/instructions/math/rem_s i32 (i32.const 11040)) + (global $assembly/instructions/math/mul_upper_s_s i32 (i32.const 11072)) + (global $assembly/instructions/math/mul_upper_u_u i32 (i32.const 11104)) + (global $assembly/instructions/math/mul_upper_s_u i32 (i32.const 11136)) + (global $assembly/instructions/math/max i32 (i32.const 11168)) + (global $assembly/instructions/math/max_u i32 (i32.const 11200)) + (global $assembly/instructions/math/min i32 (i32.const 11232)) + (global $assembly/instructions/math/min_u i32 (i32.const 11264)) + (global $assembly/instructions/mov/move_reg i32 (i32.const 11296)) + (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11328)) + (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11360)) + (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11392)) + (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11424)) + (global $assembly/instructions/rot/rot_r_64_imm i32 (i32.const 11456)) + (global $assembly/instructions/rot/rot_r_64_imm_alt i32 (i32.const 11488)) + (global $assembly/instructions/rot/rot_r_32_imm i32 (i32.const 11520)) + (global $assembly/instructions/rot/rot_r_32_imm_alt i32 (i32.const 11552)) + (global $assembly/instructions/rot/rot_l_64 i32 (i32.const 11584)) + (global $assembly/instructions/rot/rot_l_32 i32 (i32.const 11616)) + (global $assembly/instructions/rot/rot_r_64 i32 (i32.const 11648)) + (global $assembly/instructions/rot/rot_r_32 i32 (i32.const 11680)) + (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 11712)) + (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 11744)) + (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 11776)) + (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 11808)) + (global $assembly/instructions/set/set_lt_u i32 (i32.const 11840)) + (global $assembly/instructions/set/set_lt_s i32 (i32.const 11872)) + (global $assembly/instructions/shift/MAX_SHIFT_64 i32 (i32.const 64)) + (global $assembly/instructions/shift/MAX_SHIFT_32 i32 (i32.const 32)) + (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 11904)) + (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 11936)) + (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 11968)) + (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 12000)) + (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 12032)) + (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 12064)) + (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 12096)) + (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 12128)) + (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 12160)) + (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 12192)) + (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 12224)) + (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 12256)) + (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 12288)) + (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 12320)) + (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12352)) + (global $assembly/instructions/shift/shlo_l i32 (i32.const 12384)) + (global $assembly/instructions/shift/shlo_r i32 (i32.const 12416)) + (global $assembly/instructions/shift/shar_r i32 (i32.const 12448)) + (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12480)) + (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12512)) + (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12544)) + (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12576)) + (global $assembly/instructions/store/store_u8 i32 (i32.const 12608)) + (global $assembly/instructions/store/store_u16 i32 (i32.const 12640)) + (global $assembly/instructions/store/store_u32 i32 (i32.const 12672)) + (global $assembly/instructions/store/store_u64 i32 (i32.const 12704)) + (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 12736)) + (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 12768)) + (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 12800)) + (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 12832)) + (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 12864)) + (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 12896)) + (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 12928)) + (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 12960)) + (global $assembly/instructions/misc/INVALID i32 (i32.const 12992)) + (global $assembly/instructions/misc/trap i32 (i32.const 13024)) + (global $assembly/instructions/misc/fallthrough i32 (i32.const 13056)) + (global $assembly/instructions/misc/ecalli i32 (i32.const 13088)) + (global $assembly/instructions/misc/sbrk i32 (i32.const 13264)) + (global $assembly/instructions-exe/RUN i32 (i32.const 14240)) + (global $assembly/codec/MASKS i32 (i32.const 14320)) + (global $assembly/codec/variableLength i32 (i32.const 14368)) + (global $assembly/program/MAX_SKIP i32 (i32.const 24)) + (global $assembly/program/BasicBlock.NONE i32 (i32.const 0)) + (global $assembly/program/BasicBlock.START i32 (i32.const 2)) + (global $assembly/program/BasicBlock.END i32 (i32.const 4)) + (global $assembly/interpreter/Status.OK i32 (i32.const -1)) + (global $assembly/interpreter/Status.HALT i32 (i32.const 0)) + (global $assembly/interpreter/Status.PANIC i32 (i32.const 1)) + (global $assembly/interpreter/Status.FAULT i32 (i32.const 2)) + (global $assembly/interpreter/Status.HOST i32 (i32.const 3)) + (global $assembly/interpreter/Status.OOG i32 (i32.const 4)) + (global $assembly/interpreter/DjumpStatus.OK i32 (i32.const 0)) + (global $assembly/interpreter/DjumpStatus.HALT i32 (i32.const 1)) + (global $assembly/interpreter/DjumpStatus.PANIC i32 (i32.const 2)) + (global $assembly/interpreter/EXIT i32 (i32.const -65536)) + (global $assembly/interpreter/JUMP_ALIGMENT_FACTOR i32 (i32.const 2)) + (global $assembly/interpreter/MAX_U32 (mut i64) (i64.const 0)) + (global $assembly/api/interpreter (mut i32) (i32.const 0)) + (global $assembly/index/InputKind.Generic i32 (i32.const 0)) + (global $assembly/index/InputKind.SPI i32 (i32.const 1)) + (global $assembly/index/HasMetadata.Yes i32 (i32.const 0)) + (global $assembly/index/HasMetadata.No i32 (i32.const 1)) + (global $~lib/builtins/u32.MAX_VALUE i32 (i32.const -1)) + (global $~lib/rt/__rtti_base i32 (i32.const 20032)) + (global $~lib/memory/__data_end i32 (i32.const 20276)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 53044)) + (global $~lib/memory/__heap_base i32 (i32.const 53044)) + (memory $0 1) + (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") + (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $2 (i32.const 140) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") + (data $3 (i32.const 220) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00\a0\00\00\00\a0\00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $4 (i32.const 268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e\00\00\00\00\00") + (data $5 (i32.const 332) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $6 (i32.const 400) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $7 (i32.const 432) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $8 (i32.const 460) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e\00\00\00\00\00\00\00\00\00") + (data $9 (i32.const 524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $10 (i32.const 576) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $11 (i32.const 604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $12 (i32.const 668) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00") + (data $13 (i32.const 700) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $14 (i32.const 764) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") + (data $15 (i32.const 796) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") + (data $16 (i32.const 828) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\04\00\00\00\00\00\00\00\00\00\00\00") + (data $17 (i32.const 860) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\05\00\00\00\00\00\00\00\00\00\00\00") + (data $18 (i32.const 892) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\06\00\00\00\00\00\00\00\00\00\00\00") + (data $19 (i32.const 924) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\07\00\00\00\00\00\00\00\00\00\00\00") + (data $20 (i32.const 956) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00") + (data $21 (i32.const 988) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\t\00\00\00\00\00\00\00\00\00\00\00") + (data $22 (i32.const 1020) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") + (data $23 (i32.const 1052) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0b\00\00\00\00\00\00\00\00\00\00\00") + (data $24 (i32.const 1084) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0c\00\00\00\00\00\00\00\00\00\00\00") + (data $25 (i32.const 1116) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00") + (data $26 (i32.const 1148) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\b0\02\00\00\10\03\00\000\03\00\00P\03\00\00p\03\00\00\90\03\00\00\b0\03\00\00\d0\03\00\00\f0\03\00\00\10\04\00\000\04\00\00P\04\00\00p\04\00\00\00\00\00\00\00\00\00\00") + (data $27 (i32.const 1228) ",\00\00\00\00\00\00\00\00\00\00\00\07\00\00\00\10\00\00\00\90\04\00\00\90\04\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $28 (i32.const 1276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $29 (i32.const 1324) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00S\00B\00R\00K\00\00\00\00\00") + (data $30 (i32.const 1356) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00T\00R\00A\00P\00\00\00\00\00") + (data $31 (i32.const 1388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H\00\00\00\00\00\00\00") + (data $32 (i32.const 1436) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I\00") + (data $33 (i32.const 1468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00") + (data $34 (i32.const 1516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008\00\00\00\00\00") + (data $35 (i32.const 1564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006\00\00\00") + (data $36 (i32.const 1612) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002\00\00\00") + (data $37 (i32.const 1660) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004\00\00\00") + (data $38 (i32.const 1708) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00J\00U\00M\00P\00\00\00\00\00") + (data $39 (i32.const 1740) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $40 (i32.const 1788) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $41 (i32.const 1836) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $42 (i32.const 1884) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $43 (i32.const 1932) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $44 (i32.const 1980) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $45 (i32.const 2028) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $46 (i32.const 2076) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $47 (i32.const 2124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $48 (i32.const 2172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $49 (i32.const 2220) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") + (data $50 (i32.const 2268) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $51 (i32.const 2316) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $52 (i32.const 2364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $53 (i32.const 2428) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") + (data $54 (i32.const 2492) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $55 (i32.const 2556) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $56 (i32.const 2620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00\00\00") + (data $57 (i32.const 2668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M\00\00\00") + (data $58 (i32.const 2716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M\00\00\00") + (data $59 (i32.const 2764) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $60 (i32.const 2828) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $61 (i32.const 2892) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $62 (i32.const 2956) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $63 (i32.const 3020) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $64 (i32.const 3084) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $65 (i32.const 3148) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $66 (i32.const 3212) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $67 (i32.const 3276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $68 (i32.const 3324) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $69 (i32.const 3388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $70 (i32.const 3452) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00") + (data $71 (i32.const 3516) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00") + (data $72 (i32.const 3580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00") + (data $73 (i32.const 3644) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00") + (data $74 (i32.const 3708) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008\00\00\00") + (data $75 (i32.const 3756) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") + (data $76 (i32.const 3804) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") + (data $77 (i32.const 3852) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S\00\00\00") + (data $78 (i32.const 3900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00") + (data $79 (i32.const 3948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006\00\00\00") + (data $80 (i32.const 3996) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002\00\00\00") + (data $81 (i32.const 4044) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004\00\00\00") + (data $82 (i32.const 4092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00") + (data $83 (i32.const 4140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008\00\00\00\00\00\00\00") + (data $84 (i32.const 4188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00") + (data $85 (i32.const 4236) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006\00\00\00\00\00") + (data $86 (i32.const 4284) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00") + (data $87 (i32.const 4332) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002\00\00\00\00\00") + (data $88 (i32.const 4380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00") + (data $89 (i32.const 4428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") + (data $90 (i32.const 4476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $91 (i32.const 4524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $92 (i32.const 4572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M\00") + (data $93 (i32.const 4604) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") + (data $94 (i32.const 4652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") + (data $95 (i32.const 4700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") + (data $96 (i32.const 4748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $97 (i32.const 4796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $98 (i32.const 4844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $99 (i32.const 4892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00") + (data $100 (i32.const 4940) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") + (data $101 (i32.const 4988) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") + (data $102 (i32.const 5036) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $103 (i32.const 5100) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $104 (i32.const 5164) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $105 (i32.const 5228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") + (data $106 (i32.const 5276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") + (data $107 (i32.const 5324) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") + (data $108 (i32.const 5372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") + (data $109 (i32.const 5420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $110 (i32.const 5468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $111 (i32.const 5516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $112 (i32.const 5564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00") + (data $113 (i32.const 5612) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $114 (i32.const 5676) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $115 (i32.const 5740) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $116 (i32.const 5804) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00\00\00\00\00") + (data $117 (i32.const 5852) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $118 (i32.const 5916) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00\00\00\00\00") + (data $119 (i32.const 5964) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $120 (i32.const 6028) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00\00\00\00\00\00\00\00\00\00\00") + (data $121 (i32.const 6076) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00\00\00\00\00\00\00\00\00\00\00") + (data $122 (i32.const 6124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00\00\00\00\00\00\00") + (data $123 (i32.const 6172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00\00\00\00\00\00\00") + (data $124 (i32.const 6220) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00\00\00\00\00\00\00") + (data $125 (i32.const 6268) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00\00\00\00\00\00\00") + (data $126 (i32.const 6316) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00") + (data $127 (i32.const 6380) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002\00") + (data $128 (i32.const 6412) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002\00") + (data $129 (i32.const 6444) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002\00") + (data $130 (i32.const 6476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $131 (i32.const 6524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $132 (i32.const 6572) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $133 (i32.const 6620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $134 (i32.const 6668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $135 (i32.const 6716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $136 (i32.const 6764) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $137 (i32.const 6812) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004\00") + (data $138 (i32.const 6844) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004\00") + (data $139 (i32.const 6876) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004\00") + (data $140 (i32.const 6908) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $141 (i32.const 6956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $142 (i32.const 7004) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $143 (i32.const 7052) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $144 (i32.const 7100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $145 (i32.const 7148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $146 (i32.const 7196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $147 (i32.const 7244) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00A\00N\00D\00\00\00\00\00\00\00") + (data $148 (i32.const 7276) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00X\00O\00R\00\00\00\00\00\00\00") + (data $149 (i32.const 7308) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00O\00R\00\00\00\00\00\00\00\00\00") + (data $150 (i32.const 7340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S\00\00\00") + (data $151 (i32.const 7388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U\00\00\00") + (data $152 (i32.const 7436) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U\00\00\00") + (data $153 (i32.const 7484) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $154 (i32.const 7532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $155 (i32.const 7580) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $156 (i32.const 7628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $157 (i32.const 7676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $158 (i32.const 7724) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $159 (i32.const 7772) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $160 (i32.const 7820) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $161 (i32.const 7868) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $162 (i32.const 7916) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V\00") + (data $163 (i32.const 7948) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00X\00N\00O\00R\00\00\00\00\00") + (data $164 (i32.const 7980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00A\00X\00\00\00\00\00\00\00") + (data $165 (i32.const 8012) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00A\00X\00_\00U\00\00\00") + (data $166 (i32.const 8044) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00I\00N\00\00\00\00\00\00\00") + (data $167 (i32.const 8076) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00I\00N\00_\00U\00\00\00") + (data $168 (i32.const 8108) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00") + (data $169 (i32.const 8156) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h\00") + (data $170 (i32.const 8204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") + (data $171 (i32.const 8268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00") + (data $172 (i32.const 8332) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\0e\00\00\00\00\00\00\00\00\00\00\00") + (data $173 (i32.const 8364) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\0f\00\00\00\00\00\00\00\00\00\00\00") + (data $174 (i32.const 8396) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\10\00\00\00\00\00\00\00\00\00\00\00") + (data $175 (i32.const 8428) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\11\00\00\00\00\00\00\00\00\00\00\00") + (data $176 (i32.const 8460) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\12\00\00\00\00\00\00\00\00\00\00\00") + (data $177 (i32.const 8492) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\13\00\00\00\00\00\00\00\00\00\00\00") + (data $178 (i32.const 8524) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\14\00\00\00\00\00\00\00\00\00\00\00") + (data $179 (i32.const 8556) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\15\00\00\00\00\00\00\00\00\00\00\00") + (data $180 (i32.const 8588) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\16\00\00\00\00\00\00\00\00\00\00\00") + (data $181 (i32.const 8620) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\17\00\00\00\00\00\00\00\00\00\00\00") + (data $182 (i32.const 8652) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\18\00\00\00\00\00\00\00\00\00\00\00") + (data $183 (i32.const 8684) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\19\00\00\00\00\00\00\00\00\00\00\00") + (data $184 (i32.const 8716) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1a\00\00\00\00\00\00\00\00\00\00\00") + (data $185 (i32.const 8748) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1b\00\00\00\00\00\00\00\00\00\00\00") + (data $186 (i32.const 8780) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1c\00\00\00\00\00\00\00\00\00\00\00") + (data $187 (i32.const 8812) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1d\00\00\00\00\00\00\00\00\00\00\00") + (data $188 (i32.const 8844) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1e\00\00\00\00\00\00\00\00\00\00\00") + (data $189 (i32.const 8876) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1f\00\00\00\00\00\00\00\00\00\00\00") + (data $190 (i32.const 8908) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $191 (i32.const 8940) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00!\00\00\00\00\00\00\00\00\00\00\00") + (data $192 (i32.const 8972) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\"\00\00\00\00\00\00\00\00\00\00\00") + (data $193 (i32.const 9004) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00#\00\00\00\00\00\00\00\00\00\00\00") + (data $194 (i32.const 9036) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00$\00\00\00\00\00\00\00\00\00\00\00") + (data $195 (i32.const 9068) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00%\00\00\00\00\00\00\00\00\00\00\00") + (data $196 (i32.const 9100) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00&\00\00\00\00\00\00\00\00\00\00\00") + (data $197 (i32.const 9132) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\'\00\00\00\00\00\00\00\00\00\00\00") + (data $198 (i32.const 9164) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") + (data $199 (i32.const 9196) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") + (data $200 (i32.const 9228) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00*\00\00\00\00\00\00\00\00\00\00\00") + (data $201 (i32.const 9260) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00+\00\00\00\00\00\00\00\00\00\00\00") + (data $202 (i32.const 9292) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") + (data $203 (i32.const 9324) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00-\00\00\00\00\00\00\00\00\00\00\00") + (data $204 (i32.const 9356) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t\00\00\00\00\00\00\00\00\00") + (data $205 (i32.const 9420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s\00\00\00\00\00\00\00") + (data $206 (i32.const 9468) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $207 (i32.const 9596) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $208 (i32.const 9676) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00.\00\00\00\00\00\00\00\00\00\00\00") + (data $209 (i32.const 9708) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00/\00\00\00\00\00\00\00\00\00\00\00") + (data $210 (i32.const 9740) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\000\00\00\00\00\00\00\00\00\00\00\00") + (data $211 (i32.const 9772) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\001\00\00\00\00\00\00\00\00\00\00\00") + (data $212 (i32.const 9804) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\002\00\00\00\00\00\00\00\00\00\00\00") + (data $213 (i32.const 9836) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\003\00\00\00\00\00\00\00\00\00\00\00") + (data $214 (i32.const 9868) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\004\00\00\00\00\00\00\00\00\00\00\00") + (data $215 (i32.const 9900) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\005\00\00\00\00\00\00\00\00\00\00\00") + (data $216 (i32.const 9932) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\006\00\00\00\00\00\00\00\00\00\00\00") + (data $217 (i32.const 9964) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\007\00\00\00\00\00\00\00\00\00\00\00") + (data $218 (i32.const 9996) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\008\00\00\00\00\00\00\00\00\00\00\00") + (data $219 (i32.const 10028) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\009\00\00\00\00\00\00\00\00\00\00\00") + (data $220 (i32.const 10060) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00:\00\00\00\00\00\00\00\00\00\00\00") + (data $221 (i32.const 10092) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00;\00\00\00\00\00\00\00\00\00\00\00") + (data $222 (i32.const 10124) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00<\00\00\00\00\00\00\00\00\00\00\00") + (data $223 (i32.const 10156) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00=\00\00\00\00\00\00\00\00\00\00\00") + (data $224 (i32.const 10188) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00>\00\00\00\00\00\00\00\00\00\00\00") + (data $225 (i32.const 10220) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00?\00\00\00\00\00\00\00\00\00\00\00") + (data $226 (i32.const 10252) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00@\00\00\00\00\00\00\00\00\00\00\00") + (data $227 (i32.const 10284) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00A\00\00\00\00\00\00\00\00\00\00\00") + (data $228 (i32.const 10316) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00B\00\00\00\00\00\00\00\00\00\00\00") + (data $229 (i32.const 10348) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00C\00\00\00\00\00\00\00\00\00\00\00") + (data $230 (i32.const 10380) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00D\00\00\00\00\00\00\00\00\00\00\00") + (data $231 (i32.const 10412) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00E\00\00\00\00\00\00\00\00\00\00\00") + (data $232 (i32.const 10444) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00F\00\00\00\00\00\00\00\00\00\00\00") + (data $233 (i32.const 10476) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00G\00\00\00\00\00\00\00\00\00\00\00") + (data $234 (i32.const 10508) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00H\00\00\00\00\00\00\00\00\00\00\00") + (data $235 (i32.const 10540) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00I\00\00\00\00\00\00\00\00\00\00\00") + (data $236 (i32.const 10572) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00J\00\00\00\00\00\00\00\00\00\00\00") + (data $237 (i32.const 10604) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00K\00\00\00\00\00\00\00\00\00\00\00") + (data $238 (i32.const 10636) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00L\00\00\00\00\00\00\00\00\00\00\00") + (data $239 (i32.const 10668) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00M\00\00\00\00\00\00\00\00\00\00\00") + (data $240 (i32.const 10700) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00N\00\00\00\00\00\00\00\00\00\00\00") + (data $241 (i32.const 10732) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00O\00\00\00\00\00\00\00\00\00\00\00") + (data $242 (i32.const 10764) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00P\00\00\00\00\00\00\00\00\00\00\00") + (data $243 (i32.const 10796) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Q\00\00\00\00\00\00\00\00\00\00\00") + (data $244 (i32.const 10828) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00R\00\00\00\00\00\00\00\00\00\00\00") + (data $245 (i32.const 10860) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00S\00\00\00\00\00\00\00\00\00\00\00") + (data $246 (i32.const 10892) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00T\00\00\00\00\00\00\00\00\00\00\00") + (data $247 (i32.const 10924) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00U\00\00\00\00\00\00\00\00\00\00\00") + (data $248 (i32.const 10956) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00V\00\00\00\00\00\00\00\00\00\00\00") + (data $249 (i32.const 10988) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00W\00\00\00\00\00\00\00\00\00\00\00") + (data $250 (i32.const 11020) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00X\00\00\00\00\00\00\00\00\00\00\00") + (data $251 (i32.const 11052) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Y\00\00\00\00\00\00\00\00\00\00\00") + (data $252 (i32.const 11084) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Z\00\00\00\00\00\00\00\00\00\00\00") + (data $253 (i32.const 11116) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00[\00\00\00\00\00\00\00\00\00\00\00") + (data $254 (i32.const 11148) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\\\00\00\00\00\00\00\00\00\00\00\00") + (data $255 (i32.const 11180) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") + (data $256 (i32.const 11212) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00^\00\00\00\00\00\00\00\00\00\00\00") + (data $257 (i32.const 11244) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00_\00\00\00\00\00\00\00\00\00\00\00") + (data $258 (i32.const 11276) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00`\00\00\00\00\00\00\00\00\00\00\00") + (data $259 (i32.const 11308) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") + (data $260 (i32.const 11340) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") + (data $261 (i32.const 11372) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") + (data $262 (i32.const 11404) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") + (data $263 (i32.const 11436) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00e\00\00\00\00\00\00\00\00\00\00\00") + (data $264 (i32.const 11468) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00f\00\00\00\00\00\00\00\00\00\00\00") + (data $265 (i32.const 11500) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00g\00\00\00\00\00\00\00\00\00\00\00") + (data $266 (i32.const 11532) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00h\00\00\00\00\00\00\00\00\00\00\00") + (data $267 (i32.const 11564) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00i\00\00\00\00\00\00\00\00\00\00\00") + (data $268 (i32.const 11596) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00j\00\00\00\00\00\00\00\00\00\00\00") + (data $269 (i32.const 11628) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00k\00\00\00\00\00\00\00\00\00\00\00") + (data $270 (i32.const 11660) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00l\00\00\00\00\00\00\00\00\00\00\00") + (data $271 (i32.const 11692) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00m\00\00\00\00\00\00\00\00\00\00\00") + (data $272 (i32.const 11724) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00n\00\00\00\00\00\00\00\00\00\00\00") + (data $273 (i32.const 11756) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00o\00\00\00\00\00\00\00\00\00\00\00") + (data $274 (i32.const 11788) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00p\00\00\00\00\00\00\00\00\00\00\00") + (data $275 (i32.const 11820) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00q\00\00\00\00\00\00\00\00\00\00\00") + (data $276 (i32.const 11852) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00r\00\00\00\00\00\00\00\00\00\00\00") + (data $277 (i32.const 11884) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $278 (i32.const 11916) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00t\00\00\00\00\00\00\00\00\00\00\00") + (data $279 (i32.const 11948) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00u\00\00\00\00\00\00\00\00\00\00\00") + (data $280 (i32.const 11980) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00v\00\00\00\00\00\00\00\00\00\00\00") + (data $281 (i32.const 12012) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00w\00\00\00\00\00\00\00\00\00\00\00") + (data $282 (i32.const 12044) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00x\00\00\00\00\00\00\00\00\00\00\00") + (data $283 (i32.const 12076) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00y\00\00\00\00\00\00\00\00\00\00\00") + (data $284 (i32.const 12108) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00z\00\00\00\00\00\00\00\00\00\00\00") + (data $285 (i32.const 12140) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00{\00\00\00\00\00\00\00\00\00\00\00") + (data $286 (i32.const 12172) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00|\00\00\00\00\00\00\00\00\00\00\00") + (data $287 (i32.const 12204) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00}\00\00\00\00\00\00\00\00\00\00\00") + (data $288 (i32.const 12236) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00~\00\00\00\00\00\00\00\00\00\00\00") + (data $289 (i32.const 12268) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\7f\00\00\00\00\00\00\00\00\00\00\00") + (data $290 (i32.const 12300) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\80\00\00\00\00\00\00\00\00\00\00\00") + (data $291 (i32.const 12332) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\81\00\00\00\00\00\00\00\00\00\00\00") + (data $292 (i32.const 12364) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\82\00\00\00\00\00\00\00\00\00\00\00") + (data $293 (i32.const 12396) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\83\00\00\00\00\00\00\00\00\00\00\00") + (data $294 (i32.const 12428) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\84\00\00\00\00\00\00\00\00\00\00\00") + (data $295 (i32.const 12460) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\85\00\00\00\00\00\00\00\00\00\00\00") + (data $296 (i32.const 12492) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\86\00\00\00\00\00\00\00\00\00\00\00") + (data $297 (i32.const 12524) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\87\00\00\00\00\00\00\00\00\00\00\00") + (data $298 (i32.const 12556) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\88\00\00\00\00\00\00\00\00\00\00\00") + (data $299 (i32.const 12588) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\89\00\00\00\00\00\00\00\00\00\00\00") + (data $300 (i32.const 12620) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8a\00\00\00\00\00\00\00\00\00\00\00") + (data $301 (i32.const 12652) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8b\00\00\00\00\00\00\00\00\00\00\00") + (data $302 (i32.const 12684) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8c\00\00\00\00\00\00\00\00\00\00\00") + (data $303 (i32.const 12716) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8d\00\00\00\00\00\00\00\00\00\00\00") + (data $304 (i32.const 12748) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8e\00\00\00\00\00\00\00\00\00\00\00") + (data $305 (i32.const 12780) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8f\00\00\00\00\00\00\00\00\00\00\00") + (data $306 (i32.const 12812) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\90\00\00\00\00\00\00\00\00\00\00\00") + (data $307 (i32.const 12844) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\91\00\00\00\00\00\00\00\00\00\00\00") + (data $308 (i32.const 12876) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\92\00\00\00\00\00\00\00\00\00\00\00") + (data $309 (i32.const 12908) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\93\00\00\00\00\00\00\00\00\00\00\00") + (data $310 (i32.const 12940) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\94\00\00\00\00\00\00\00\00\00\00\00") + (data $311 (i32.const 12972) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\95\00\00\00\00\00\00\00\00\00\00\00") + (data $312 (i32.const 13004) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\96\00\00\00\00\00\00\00\00\00\00\00") + (data $313 (i32.const 13036) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\97\00\00\00\00\00\00\00\00\00\00\00") + (data $314 (i32.const 13068) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\98\00\00\00\00\00\00\00\00\00\00\00") + (data $315 (i32.const 13100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y\00") + (data $316 (i32.const 13148) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.\00") + (data $317 (i32.const 13244) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\99\00\00\00\00\00\00\00\00\00\00\00") + (data $318 (i32.const 13276) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00\e02\00\00\003\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 3\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00`$\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c00\00\00\e00\00\00\001\00\00 1\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\e0#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\00$\00\00\80$\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00@1\00\00`1\00\00\801\00\00\a01\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c01\00\00\e01\00\00\002\00\00 2\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 $\00\00\e0!\00\00\00\"\00\00 \"\00\00@\"\00\00`\"\00\00\80\"\00\00\a0\"\00\00\c0\"\00\00\e0\"\00\00\00#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 ,\00\00\d03\00\00\a0 \00\00\c0 \00\00\e0 \00\00\00!\00\00 !\00\00@!\00\00`!\00\00\80!\00\00\a0!\00\00\c0!\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00@2\00\00`2\00\00\802\00\00\a02\00\00\c0&\00\00\e0&\00\00\00\'\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\c0(\00\00\a0\'\00\00\c0\'\00\00\e0\'\00\00\e0(\00\00\c0-\00\00\e0-\00\00\80.\00\00\a0.\00\00\c0.\00\00\00)\00\00\00.\00\00 .\00\00\e0.\00\00\00/\00\00 /\00\00@,\00\00`,\00\00 )\00\00@)\00\00@/\00\00`/\00\00\80/\00\00`)\00\00\a0/\00\00\c0/\00\00\e0/\00\00\c0,\00\00\e0,\00\00\00-\00\00 -\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 #\00\00@#\00\00`#\00\00\80#\00\00\a0#\00\00\c0#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00@$\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\80)\00\00\a0)\00\00\c0)\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\00\000\00\00 0\00\00@0\00\00`*\00\00\80*\00\00\a0*\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00`0\00\00\800\00\00\a00\00\00\00(\00\00 (\00\00@(\00\00@+\00\00`+\00\00\80+\00\00@.\00\00`.\00\00\80,\00\00\a0,\00\00@-\00\00`-\00\00\80-\00\00\a0-\00\00`(\00\00\80(\00\00\a0(\00\00\a0+\00\00\c0+\00\00\e0+\00\00\00,\00\00") + (data $319 (i32.const 14220) ",\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\10\00\00\00\f03\00\00\f03\00\00\9c\03\00\00\e7\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $320 (i32.const 14268) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80\00\00\00\00") + (data $321 (i32.const 14300) ",\00\00\00\00\00\00\00\00\00\00\00\1b\00\00\00\10\00\00\00\d07\00\00\d07\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $322 (i32.const 14348) "\1c\00\00\00\00\00\00\00\00\00\00\00\1c\00\00\00\08\00\00\00\9a\00\00\00\00\00\00\00\00\00\00\00") + (data $323 (i32.const 14380) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $324 (i32.const 14412) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 \00\00\00") + (data $325 (i32.const 14492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $326 (i32.const 14540) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00`8\00\00\00\00\00\00\b08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $327 (i32.const 14588) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006\00\00\00\00\00\00\00\00\00") + (data $328 (i32.const 14716) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") + (data $329 (i32.const 14780) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\000\00\00\00\00\00\00\00\00\00\00\00") + (data $330 (i32.const 14812) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\00") + (data $331 (i32.const 15212) "\1c\04\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $332 (i32.const 16268) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z\00\00\00\00\00") + (data $333 (i32.const 16364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $334 (i32.const 16428) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 \00\00\00\00\00\00\00\00\00") + (data $335 (i32.const 16540) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $336 (i32.const 16588) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00@@\00\00\00\00\00\00\b0@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $337 (i32.const 16636) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n\00\00\00\00\00\00\00") + (data $338 (i32.const 16684) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\000\00x\00\00\00\00\00\00\00\00\00") + (data $339 (i32.const 16716) "\1c\00\00\00\00\00\00\00\00\00\00\00)\00\00\00\08\00\00\00\9b\00\00\00\00\00\00\00\00\00\00\00") + (data $340 (i32.const 16748) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00\n\00\n\00\00\00\00\00\00\00\00\00") + (data $341 (i32.const 16780) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $342 (i32.const 16908) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>\00\00\00") + (data $343 (i32.const 16988) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!\00\00\00\00\00\00\00\00\00\00\00") + (data $344 (i32.const 17100) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00g\00e\00n\00e\00r\00i\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $345 (i32.const 17180) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") + (data $346 (i32.const 17212) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00:\00 \00\00\00\00\00\00\00\00\00") + (data $347 (i32.const 17244) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") + (data $348 (i32.const 17276) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") + (data $349 (i32.const 17308) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pC\00\00\00\00\00\00\90C\00\00") + (data $350 (i32.const 17340) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $351 (i32.const 17372) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00,\00 \00\00\00\00\00\00\00\00\00") + (data $352 (i32.const 17404) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00\d0C\00\00\00\00\00\00\f0C\00\00") + (data $353 (i32.const 17436) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") + (data $354 (i32.const 17564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 \00") + (data $355 (i32.const 17612) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $356 (i32.const 17644) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $357 (i32.const 17676) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $358 (i32.const 17708) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $359 (i32.const 17740) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 \00") + (data $360 (i32.const 17836) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $361 (i32.const 17900) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!\00\00\00\00\00\00\00") + (data $362 (i32.const 18012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 \00\00\00\00\00") + (data $363 (i32.const 18060) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $364 (i32.const 18108) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pF\00\00\00\00\00\00\a0F\00\00") + (data $365 (i32.const 18140) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pF\00\00\00\00\00\00\a0F\00\00") + (data $366 (i32.const 18172) "\1c\00\00\00\00\00\00\00\00\00\00\005\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") + (data $367 (i32.const 18204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 \00") + (data $368 (i32.const 18268) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00P\00C\00 \00=\00 \00\00\00") + (data $369 (i32.const 18300) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $370 (i32.const 18348) "\1c\00\00\00\00\00\00\00\00\00\00\005\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") + (data $371 (i32.const 18380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 \00") + (data $372 (i32.const 18428) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00(\00\00\00\00\00\00\00\00\00") + (data $373 (i32.const 18460) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\14\00\00\00\e0G\00\00\00\00\00\00\10H\00\00\00\00\00\00\90C\00\00\00\00\00\00\00\00\00\00") + (data $374 (i32.const 18508) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 \00\00\00\00\00\00\00\00\00") + (data $375 (i32.const 18588) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00") + (data $376 (i32.const 18652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 \00\00\00") + (data $377 (i32.const 18700) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x\00") + (data $378 (i32.const 18732) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 \00\00\00") + (data $379 (i32.const 18764) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00,\00\n\00 \00 \00\00\00\00\00") + (data $380 (i32.const 18796) "|\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00`\00\00\00\f0H\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00@I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00`I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00`I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $381 (i32.const 18924) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t\00") + (data $382 (i32.const 18972) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $383 (i32.const 19052) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $384 (i32.const 19084) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $385 (i32.const 19116) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $386 (i32.const 19148) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $387 (i32.const 19180) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00S\00P\00I\00 \00r\00u\00n\00n\00i\00n\00g\00 \00n\00o\00t\00 \00s\00u\00p\00p\00o\00r\00t\00e\00d\00 \00y\00e\00t\00\00\00") + (data $388 (i32.const 19260) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00d\00e\00x\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $389 (i32.const 19324) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $390 (i32.const 19404) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $391 (i32.const 19436) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $392 (i32.const 19500) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 \00\00\00\00\00\00\00") + (data $393 (i32.const 19580) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00") + (data $394 (i32.const 19676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 \00\00\00\00\00") + (data $395 (i32.const 19724) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00\90L\00\00\00\00\00\00\f0L\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $396 (i32.const 19772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $397 (i32.const 19836) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $398 (i32.const 19868) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $399 (i32.const 19900) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d\00\00\00") + (data $400 (i32.const 19964) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d\00\00\00\00\00") + (data $401 (i32.const 20032) "<\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\02A\00\00B\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\01\00\00\00\00\00\00\00\00\00\00$\t\00\00 \00\00\00\00\00\00\00\00\00\00\00\04A\00\00 \00\00\00\00\00\00\00\02\01\00\00\02\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00\00\00\00\00 \00\00\00 \00\00\00\02A\00\00d\00\00\00\00\00\00\00") + (table $0 158 158 funcref) + (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $assembly/index/disassemble~anonymous|0 $assembly/api-generic/runVm~anonymous|0 $assembly/api-generic/runVm~anonymous|1) + (export "InputKind.Generic" (global $assembly/index/InputKind.Generic)) + (export "InputKind.SPI" (global $assembly/index/InputKind.SPI)) + (export "HasMetadata.Yes" (global $assembly/index/HasMetadata.Yes)) + (export "HasMetadata.No" (global $assembly/index/HasMetadata.No)) + (export "nextStep" (func $assembly/api/nextStep)) + (export "nSteps" (func $assembly/api/nSteps)) + (export "getProgramCounter" (func $assembly/api/getProgramCounter)) + (export "setNextProgramCounter" (func $assembly/api/setNextProgramCounter)) + (export "getStatus" (func $assembly/api/getStatus)) + (export "getExitArg" (func $assembly/api/getExitArg)) + (export "getGasLeft" (func $assembly/api/getGasLeft)) + (export "setGasLeft" (func $assembly/api/setGasLeft)) + (export "getRegisters" (func $assembly/api/getRegisters)) + (export "getPageDump" (func $assembly/api/getPageDump)) + (export "__new" (func $~lib/rt/itcms/__new)) + (export "__pin" (func $~lib/rt/itcms/__pin)) + (export "__unpin" (func $~lib/rt/itcms/__unpin)) + (export "__collect" (func $~lib/rt/itcms/__collect)) + (export "__rtti_base" (global $~lib/rt/__rtti_base)) + (export "memory" (memory $0)) + (export "__setArgumentsLength" (func $~setArgumentsLength)) + (export "disassemble" (func $export:assembly/index/disassemble)) + (export "runProgram" (func $export:assembly/index/runProgram)) + (export "runVm" (func $export:assembly/api-generic/runVm@varargs)) + (export "getAssembly" (func $export:assembly/api-generic/getAssembly)) + (export "wrapAsProgram" (func $export:assembly/program-build/wrapAsProgram)) + (export "resetGeneric" (func $export:assembly/api/resetGeneric)) + (export "resetGenericWithMemory" (func $export:assembly/api/resetGenericWithMemory)) + (export "setRegisters" (func $export:assembly/api/setRegisters)) + (export "setMemory" (func $export:assembly/api/setMemory)) + (start $~start) + (func $~lib/rt/itcms/Object#set:nextWithColor (param $this i32) (param $nextWithColor i32) + local.get $this + local.get $nextWithColor + i32.store offset=4 + ) + (func $~lib/rt/itcms/Object#set:prev (param $this i32) (param $prev i32) + local.get $this + local.get $prev + i32.store offset=8 + ) + (func $~lib/rt/itcms/initLazy (param $space i32) (result i32) + local.get $space + local.get $space + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $space + local.get $space + call $~lib/rt/itcms/Object#set:prev + local.get $space + return + ) + (func $~lib/rt/itcms/Object#get:nextWithColor (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/rt/itcms/Object#get:next (param $this i32) (result i32) + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.const -1 + i32.xor + i32.and + return + ) + (func $~lib/rt/itcms/Object#get:color (param $this i32) (result i32) + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.and + return + ) + (func $~lib/rt/itcms/visitRoots (param $cookie i32) + (local $pn i32) + (local $iter i32) + local.get $cookie + call $~lib/rt/__visit_globals + global.get $~lib/rt/itcms/pinSpace + local.set $pn + local.get $pn + call $~lib/rt/itcms/Object#get:next + local.set $iter + loop $while-continue|0 + local.get $iter + local.get $pn + i32.ne + if + i32.const 1 + drop + local.get $iter + call $~lib/rt/itcms/Object#get:color + i32.const 3 + i32.eq + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 160 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $iter + i32.const 20 + i32.add + local.get $cookie + call $~lib/rt/__visit_members + local.get $iter + call $~lib/rt/itcms/Object#get:next + local.set $iter + br $while-continue|0 + end + end + ) + (func $~lib/rt/itcms/Object#set:color (param $this i32) (param $color i32) + local.get $this + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $color + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + ) + (func $~lib/rt/itcms/Object#get:prev (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/rt/itcms/Object#set:next (param $this i32) (param $obj i32) + local.get $this + local.get $obj + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.and + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + ) + (func $~lib/rt/itcms/Object#unlink (param $this i32) + (local $next i32) + (local $prev i32) + local.get $this + call $~lib/rt/itcms/Object#get:next + local.set $next + local.get $next + i32.const 0 + i32.eq + if + i32.const 1 + drop + local.get $this + call $~lib/rt/itcms/Object#get:prev + i32.const 0 + i32.eq + if (result i32) + local.get $this + global.get $~lib/memory/__heap_base + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 128 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + return + end + local.get $this + call $~lib/rt/itcms/Object#get:prev + local.set $prev + i32.const 1 + drop + local.get $prev + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 132 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $next + local.get $prev + call $~lib/rt/itcms/Object#set:prev + local.get $prev + local.get $next + call $~lib/rt/itcms/Object#set:next + ) + (func $~lib/rt/itcms/Object#get:rtId (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/shared/typeinfo/Typeinfo#get:flags (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/__typeinfo (param $id i32) (result i32) + (local $ptr i32) + global.get $~lib/rt/__rtti_base + local.set $ptr + local.get $id + local.get $ptr + i32.load + i32.gt_u + if + i32.const 480 + i32.const 544 + i32.const 21 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $ptr + i32.const 4 + i32.add + local.get $id + i32.const 4 + i32.mul + i32.add + call $~lib/shared/typeinfo/Typeinfo#get:flags + return + ) + (func $~lib/rt/itcms/Object#get:isPointerfree (param $this i32) (result i32) + (local $rtId i32) + local.get $this + call $~lib/rt/itcms/Object#get:rtId + local.set $rtId + local.get $rtId + i32.const 2 + i32.le_u + if (result i32) + i32.const 1 + else + local.get $rtId + call $~lib/rt/__typeinfo + i32.const 32 + i32.and + i32.const 0 + i32.ne + end + return + ) + (func $~lib/rt/itcms/Object#linkTo (param $this i32) (param $list i32) (param $withColor i32) + (local $prev i32) + local.get $list + call $~lib/rt/itcms/Object#get:prev + local.set $prev + local.get $this + local.get $list + local.get $withColor + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $this + local.get $prev + call $~lib/rt/itcms/Object#set:prev + local.get $prev + local.get $this + call $~lib/rt/itcms/Object#set:next + local.get $list + local.get $this + call $~lib/rt/itcms/Object#set:prev + ) + (func $~lib/rt/itcms/Object#makeGray (param $this i32) + (local $1 i32) + local.get $this + global.get $~lib/rt/itcms/iter + i32.eq + if + local.get $this + call $~lib/rt/itcms/Object#get:prev + local.tee $1 + i32.eqz + if (result i32) + i32.const 0 + i32.const 352 + i32.const 148 + i32.const 30 + call $~lib/builtins/abort + unreachable + else + local.get $1 + end + global.set $~lib/rt/itcms/iter + end + local.get $this + call $~lib/rt/itcms/Object#unlink + local.get $this + global.get $~lib/rt/itcms/toSpace + local.get $this + call $~lib/rt/itcms/Object#get:isPointerfree + if (result i32) + global.get $~lib/rt/itcms/white + i32.eqz + else + i32.const 2 + end + call $~lib/rt/itcms/Object#linkTo + ) + (func $~lib/rt/itcms/__visit (param $ptr i32) (param $cookie i32) + (local $obj i32) + local.get $ptr + i32.eqz + if + return + end + local.get $ptr + i32.const 20 + i32.sub + local.set $obj + i32.const 0 + drop + local.get $obj + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eq + if + local.get $obj + call $~lib/rt/itcms/Object#makeGray + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.add + global.set $~lib/rt/itcms/visitCount + end + ) + (func $~lib/rt/itcms/visitStack (param $cookie i32) + (local $ptr i32) + global.get $~lib/memory/__stack_pointer + local.set $ptr + loop $while-continue|0 + local.get $ptr + global.get $~lib/memory/__heap_base + i32.lt_u + if + local.get $ptr + i32.load + local.get $cookie + call $~lib/rt/itcms/__visit + local.get $ptr + i32.const 4 + i32.add + local.set $ptr + br $while-continue|0 + end + end + ) + (func $~lib/rt/common/BLOCK#get:mmInfo (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/itcms/Object#get:size (param $this i32) (result i32) + i32.const 4 + local.get $this + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + return + ) + (func $~lib/rt/tlsf/Root#set:flMap (param $this i32) (param $flMap i32) + local.get $this + local.get $flMap + i32.store + ) + (func $~lib/rt/common/BLOCK#set:mmInfo (param $this i32) (param $mmInfo i32) + local.get $this + local.get $mmInfo + i32.store + ) + (func $~lib/rt/tlsf/Block#set:prev (param $this i32) (param $prev i32) + local.get $this + local.get $prev + i32.store offset=4 + ) + (func $~lib/rt/tlsf/Block#set:next (param $this i32) (param $next i32) + local.get $this + local.get $next + i32.store offset=8 + ) + (func $~lib/rt/tlsf/Block#get:prev (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/rt/tlsf/Block#get:next (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/rt/tlsf/Root#get:flMap (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/tlsf/removeBlock (param $root i32) (param $block i32) + (local $blockInfo i32) + (local $size i32) + (local $fl i32) + (local $sl i32) + (local $6 i32) + (local $7 i32) + (local $boundedSize i32) + (local $prev i32) + (local $next i32) + (local $root|11 i32) + (local $fl|12 i32) + (local $sl|13 i32) + (local $root|14 i32) + (local $fl|15 i32) + (local $sl|16 i32) + (local $head i32) + (local $root|18 i32) + (local $fl|19 i32) + (local $slMap i32) + (local $root|21 i32) + (local $fl|22 i32) + (local $slMap|23 i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $blockInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 268 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.set $size + i32.const 1 + drop + local.get $size + i32.const 12 + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 270 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + local.tee $6 + i32.const 1073741820 + local.tee $7 + local.get $6 + local.get $7 + i32.lt_u + select + local.set $boundedSize + i32.const 31 + local.get $boundedSize + i32.clz + i32.sub + local.set $fl + local.get $boundedSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 284 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $block + call $~lib/rt/tlsf/Block#get:prev + local.set $prev + local.get $block + call $~lib/rt/tlsf/Block#get:next + local.set $next + local.get $prev + if + local.get $prev + local.get $next + call $~lib/rt/tlsf/Block#set:next + end + local.get $next + if + local.get $next + local.get $prev + call $~lib/rt/tlsf/Block#set:prev + end + local.get $block + block $~lib/rt/tlsf/GETHEAD|inlined.0 (result i32) + local.get $root + local.set $root|11 + local.get $fl + local.set $fl|12 + local.get $sl + local.set $sl|13 + local.get $root|11 + local.get $fl|12 + i32.const 4 + i32.shl + local.get $sl|13 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.0 + end + i32.eq + if + local.get $root + local.set $root|14 + local.get $fl + local.set $fl|15 + local.get $sl + local.set $sl|16 + local.get $next + local.set $head + local.get $root|14 + local.get $fl|15 + i32.const 4 + i32.shl + local.get $sl|16 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head + i32.store offset=96 + local.get $next + i32.eqz + if + block $~lib/rt/tlsf/GETSL|inlined.0 (result i32) + local.get $root + local.set $root|18 + local.get $fl + local.set $fl|19 + local.get $root|18 + local.get $fl|19 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.0 + end + local.set $slMap + local.get $root + local.set $root|21 + local.get $fl + local.set $fl|22 + local.get $slMap + i32.const 1 + local.get $sl + i32.shl + i32.const -1 + i32.xor + i32.and + local.tee $slMap + local.set $slMap|23 + local.get $root|21 + local.get $fl|22 + i32.const 2 + i32.shl + i32.add + local.get $slMap|23 + i32.store offset=4 + local.get $slMap + i32.eqz + if + local.get $root + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 1 + local.get $fl + i32.shl + i32.const -1 + i32.xor + i32.and + call $~lib/rt/tlsf/Root#set:flMap + end + end + end + ) + (func $~lib/rt/tlsf/insertBlock (param $root i32) (param $block i32) + (local $blockInfo i32) + (local $block|3 i32) + (local $right i32) + (local $rightInfo i32) + (local $block|6 i32) + (local $block|7 i32) + (local $left i32) + (local $leftInfo i32) + (local $size i32) + (local $fl i32) + (local $sl i32) + (local $13 i32) + (local $14 i32) + (local $boundedSize i32) + (local $root|16 i32) + (local $fl|17 i32) + (local $sl|18 i32) + (local $head i32) + (local $root|20 i32) + (local $fl|21 i32) + (local $sl|22 i32) + (local $head|23 i32) + (local $root|24 i32) + (local $fl|25 i32) + (local $root|26 i32) + (local $fl|27 i32) + (local $slMap i32) + i32.const 1 + drop + local.get $block + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 201 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $blockInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 203 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETRIGHT|inlined.0 (result i32) + local.get $block + local.set $block|3 + local.get $block|3 + i32.const 4 + i32.add + local.get $block|3 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.0 + end + local.set $right + local.get $right + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $rightInfo + local.get $rightInfo + i32.const 1 + i32.and + if + local.get $root + local.get $right + call $~lib/rt/tlsf/removeBlock + local.get $block + local.get $blockInfo + i32.const 4 + i32.add + local.get $rightInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + local.tee $blockInfo + call $~lib/rt/common/BLOCK#set:mmInfo + block $~lib/rt/tlsf/GETRIGHT|inlined.1 (result i32) + local.get $block + local.set $block|6 + local.get $block|6 + i32.const 4 + i32.add + local.get $block|6 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.1 + end + local.set $right + local.get $right + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $rightInfo + end + local.get $blockInfo + i32.const 2 + i32.and + if + block $~lib/rt/tlsf/GETFREELEFT|inlined.0 (result i32) + local.get $block + local.set $block|7 + local.get $block|7 + i32.const 4 + i32.sub + i32.load + br $~lib/rt/tlsf/GETFREELEFT|inlined.0 + end + local.set $left + local.get $left + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $leftInfo + i32.const 1 + drop + local.get $leftInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 221 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $root + local.get $left + call $~lib/rt/tlsf/removeBlock + local.get $left + local.set $block + local.get $block + local.get $leftInfo + i32.const 4 + i32.add + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + local.tee $blockInfo + call $~lib/rt/common/BLOCK#set:mmInfo + end + local.get $right + local.get $rightInfo + i32.const 2 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.set $size + i32.const 1 + drop + local.get $size + i32.const 12 + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 233 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + i32.const 1 + drop + local.get $block + i32.const 4 + i32.add + local.get $size + i32.add + local.get $right + i32.eq + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 234 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $right + i32.const 4 + i32.sub + local.get $block + i32.store + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + local.tee $13 + i32.const 1073741820 + local.tee $14 + local.get $13 + local.get $14 + i32.lt_u + select + local.set $boundedSize + i32.const 31 + local.get $boundedSize + i32.clz + i32.sub + local.set $fl + local.get $boundedSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 251 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETHEAD|inlined.1 (result i32) + local.get $root + local.set $root|16 + local.get $fl + local.set $fl|17 + local.get $sl + local.set $sl|18 + local.get $root|16 + local.get $fl|17 + i32.const 4 + i32.shl + local.get $sl|18 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.1 + end + local.set $head + local.get $block + i32.const 0 + call $~lib/rt/tlsf/Block#set:prev + local.get $block + local.get $head + call $~lib/rt/tlsf/Block#set:next + local.get $head + if + local.get $head + local.get $block + call $~lib/rt/tlsf/Block#set:prev + end + local.get $root + local.set $root|20 + local.get $fl + local.set $fl|21 + local.get $sl + local.set $sl|22 + local.get $block + local.set $head|23 + local.get $root|20 + local.get $fl|21 + i32.const 4 + i32.shl + local.get $sl|22 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head|23 + i32.store offset=96 + local.get $root + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 1 + local.get $fl + i32.shl + i32.or + call $~lib/rt/tlsf/Root#set:flMap + local.get $root + local.set $root|26 + local.get $fl + local.set $fl|27 + block $~lib/rt/tlsf/GETSL|inlined.1 (result i32) + local.get $root + local.set $root|24 + local.get $fl + local.set $fl|25 + local.get $root|24 + local.get $fl|25 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.1 + end + i32.const 1 + local.get $sl + i32.shl + i32.or + local.set $slMap + local.get $root|26 + local.get $fl|27 + i32.const 2 + i32.shl + i32.add + local.get $slMap + i32.store offset=4 + ) + (func $~lib/rt/tlsf/addMemory (param $root i32) (param $start i32) (param $endU64 i64) (result i32) + (local $end i32) + (local $root|4 i32) + (local $tail i32) + (local $tailInfo i32) + (local $size i32) + (local $leftSize i32) + (local $left i32) + (local $root|10 i32) + (local $tail|11 i32) + local.get $endU64 + i32.wrap_i64 + local.set $end + i32.const 1 + drop + local.get $start + i64.extend_i32_u + local.get $endU64 + i64.le_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 382 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $start + i32.const 4 + i32.add + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + i32.const 4 + i32.sub + local.set $start + local.get $end + i32.const 15 + i32.const -1 + i32.xor + i32.and + local.set $end + block $~lib/rt/tlsf/GETTAIL|inlined.0 (result i32) + local.get $root + local.set $root|4 + local.get $root|4 + i32.load offset=1568 + br $~lib/rt/tlsf/GETTAIL|inlined.0 + end + local.set $tail + i32.const 0 + local.set $tailInfo + local.get $tail + if + i32.const 1 + drop + local.get $start + local.get $tail + i32.const 4 + i32.add + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 389 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $start + i32.const 16 + i32.sub + local.get $tail + i32.eq + if + local.get $start + i32.const 16 + i32.sub + local.set $start + local.get $tail + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $tailInfo + else + end + else + i32.const 1 + drop + local.get $start + local.get $root + i32.const 1572 + i32.add + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 402 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + end + local.get $end + local.get $start + i32.sub + local.set $size + local.get $size + i32.const 4 + i32.const 12 + i32.add + i32.const 4 + i32.add + i32.lt_u + if + i32.const 0 + return + end + local.get $size + i32.const 2 + i32.const 4 + i32.mul + i32.sub + local.set $leftSize + local.get $start + local.set $left + local.get $left + local.get $leftSize + i32.const 1 + i32.or + local.get $tailInfo + i32.const 2 + i32.and + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $left + i32.const 0 + call $~lib/rt/tlsf/Block#set:prev + local.get $left + i32.const 0 + call $~lib/rt/tlsf/Block#set:next + local.get $start + i32.const 4 + i32.add + local.get $leftSize + i32.add + local.set $tail + local.get $tail + i32.const 0 + i32.const 2 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.set $root|10 + local.get $tail + local.set $tail|11 + local.get $root|10 + local.get $tail|11 + i32.store offset=1568 + local.get $root + local.get $left + call $~lib/rt/tlsf/insertBlock + i32.const 1 + return + ) + (func $~lib/rt/tlsf/initialize + (local $rootOffset i32) + (local $pagesBefore i32) + (local $pagesNeeded i32) + (local $root i32) + (local $root|4 i32) + (local $tail i32) + (local $fl i32) + (local $root|7 i32) + (local $fl|8 i32) + (local $slMap i32) + (local $sl i32) + (local $root|11 i32) + (local $fl|12 i32) + (local $sl|13 i32) + (local $head i32) + (local $memStart i32) + i32.const 0 + drop + global.get $~lib/memory/__heap_base + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + local.set $rootOffset + memory.size + local.set $pagesBefore + local.get $rootOffset + i32.const 1572 + i32.add + i32.const 65535 + i32.add + i32.const 65535 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.shr_u + local.set $pagesNeeded + local.get $pagesNeeded + local.get $pagesBefore + i32.gt_s + if (result i32) + local.get $pagesNeeded + local.get $pagesBefore + i32.sub + memory.grow + i32.const 0 + i32.lt_s + else + i32.const 0 + end + if + unreachable + end + local.get $rootOffset + local.set $root + local.get $root + i32.const 0 + call $~lib/rt/tlsf/Root#set:flMap + local.get $root + local.set $root|4 + i32.const 0 + local.set $tail + local.get $root|4 + local.get $tail + i32.store offset=1568 + i32.const 0 + local.set $fl + loop $for-loop|0 + local.get $fl + i32.const 23 + i32.lt_u + if + local.get $root + local.set $root|7 + local.get $fl + local.set $fl|8 + i32.const 0 + local.set $slMap + local.get $root|7 + local.get $fl|8 + i32.const 2 + i32.shl + i32.add + local.get $slMap + i32.store offset=4 + i32.const 0 + local.set $sl + loop $for-loop|1 + local.get $sl + i32.const 16 + i32.lt_u + if + local.get $root + local.set $root|11 + local.get $fl + local.set $fl|12 + local.get $sl + local.set $sl|13 + i32.const 0 + local.set $head + local.get $root|11 + local.get $fl|12 + i32.const 4 + i32.shl + local.get $sl|13 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head + i32.store offset=96 + local.get $sl + i32.const 1 + i32.add + local.set $sl + br $for-loop|1 + end + end + local.get $fl + i32.const 1 + i32.add + local.set $fl + br $for-loop|0 + end + end + local.get $rootOffset + i32.const 1572 + i32.add + local.set $memStart + i32.const 0 + drop + local.get $root + local.get $memStart + memory.size + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + drop + local.get $root + global.set $~lib/rt/tlsf/ROOT + ) + (func $~lib/rt/tlsf/checkUsedBlock (param $ptr i32) (result i32) + (local $block i32) + local.get $ptr + i32.const 4 + i32.sub + local.set $block + local.get $ptr + i32.const 0 + i32.ne + if (result i32) + local.get $ptr + i32.const 15 + i32.and + i32.eqz + else + i32.const 0 + end + if (result i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 1 + i32.and + i32.eqz + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 562 + i32.const 3 + call $~lib/builtins/abort + unreachable + end + local.get $block + return + ) + (func $~lib/rt/tlsf/freeBlock (param $root i32) (param $block i32) + i32.const 0 + drop + local.get $block + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 1 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.get $block + call $~lib/rt/tlsf/insertBlock + ) + (func $~lib/rt/tlsf/__free (param $ptr i32) + local.get $ptr + global.get $~lib/memory/__heap_base + i32.lt_u + if + return + end + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $ptr + call $~lib/rt/tlsf/checkUsedBlock + call $~lib/rt/tlsf/freeBlock + ) + (func $~lib/rt/itcms/free (param $obj i32) + local.get $obj + global.get $~lib/memory/__heap_base + i32.lt_u + if + local.get $obj + i32.const 0 + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $obj + i32.const 0 + call $~lib/rt/itcms/Object#set:prev + else + global.get $~lib/rt/itcms/total + local.get $obj + call $~lib/rt/itcms/Object#get:size + i32.sub + global.set $~lib/rt/itcms/total + i32.const 0 + drop + local.get $obj + i32.const 4 + i32.add + call $~lib/rt/tlsf/__free + end + ) + (func $~lib/rt/itcms/step (result i32) + (local $obj i32) + (local $1 i32) + (local $black i32) + (local $from i32) + block $break|0 + block $case2|0 + block $case1|0 + block $case0|0 + global.get $~lib/rt/itcms/state + local.set $1 + local.get $1 + i32.const 0 + i32.eq + br_if $case0|0 + local.get $1 + i32.const 1 + i32.eq + br_if $case1|0 + local.get $1 + i32.const 2 + i32.eq + br_if $case2|0 + br $break|0 + end + i32.const 1 + global.set $~lib/rt/itcms/state + i32.const 0 + global.set $~lib/rt/itcms/visitCount + i32.const 0 + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/iter + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + global.get $~lib/rt/itcms/white + i32.eqz + local.set $black + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + loop $while-continue|1 + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + global.set $~lib/rt/itcms/iter + local.get $obj + call $~lib/rt/itcms/Object#get:color + local.get $black + i32.ne + if + local.get $obj + local.get $black + call $~lib/rt/itcms/Object#set:color + i32.const 0 + global.set $~lib/rt/itcms/visitCount + local.get $obj + i32.const 20 + i32.add + i32.const 0 + call $~lib/rt/__visit_members + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + local.get $obj + call $~lib/rt/itcms/Object#get:next + local.set $obj + br $while-continue|1 + end + end + i32.const 0 + global.set $~lib/rt/itcms/visitCount + i32.const 0 + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.eq + if + i32.const 0 + call $~lib/rt/itcms/visitStack + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + loop $while-continue|2 + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + call $~lib/rt/itcms/Object#get:color + local.get $black + i32.ne + if + local.get $obj + local.get $black + call $~lib/rt/itcms/Object#set:color + local.get $obj + i32.const 20 + i32.add + i32.const 0 + call $~lib/rt/__visit_members + end + local.get $obj + call $~lib/rt/itcms/Object#get:next + local.set $obj + br $while-continue|2 + end + end + global.get $~lib/rt/itcms/fromSpace + local.set $from + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/fromSpace + local.get $from + global.set $~lib/rt/itcms/toSpace + local.get $black + global.set $~lib/rt/itcms/white + local.get $from + call $~lib/rt/itcms/Object#get:next + global.set $~lib/rt/itcms/iter + i32.const 2 + global.set $~lib/rt/itcms/state + end + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + global.get $~lib/rt/itcms/iter + local.set $obj + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + call $~lib/rt/itcms/Object#get:next + global.set $~lib/rt/itcms/iter + i32.const 1 + drop + local.get $obj + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eqz + i32.eq + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 229 + i32.const 20 + call $~lib/builtins/abort + unreachable + end + local.get $obj + call $~lib/rt/itcms/free + i32.const 10 + return + end + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + call $~lib/rt/itcms/Object#set:nextWithColor + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + call $~lib/rt/itcms/Object#set:prev + i32.const 0 + global.set $~lib/rt/itcms/state + br $break|0 + end + i32.const 0 + return + ) + (func $~lib/rt/itcms/interrupt + (local $budget i32) + i32.const 0 + drop + i32.const 0 + drop + i32.const 1024 + i32.const 200 + i32.mul + i32.const 100 + i32.div_u + local.set $budget + loop $do-loop|0 + local.get $budget + call $~lib/rt/itcms/step + i32.sub + local.set $budget + global.get $~lib/rt/itcms/state + i32.const 0 + i32.eq + if + i32.const 0 + drop + global.get $~lib/rt/itcms/total + i64.extend_i32_u + i32.const 200 + i64.extend_i32_u + i64.mul + i64.const 100 + i64.div_u + i32.wrap_i64 + i32.const 1024 + i32.add + global.set $~lib/rt/itcms/threshold + i32.const 0 + drop + return + end + local.get $budget + i32.const 0 + i32.gt_s + br_if $do-loop|0 + end + i32.const 0 + drop + global.get $~lib/rt/itcms/total + i32.const 1024 + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.sub + i32.const 1024 + i32.lt_u + i32.mul + i32.add + global.set $~lib/rt/itcms/threshold + i32.const 0 + drop + ) + (func $~lib/rt/tlsf/computeSize (param $size i32) (result i32) + local.get $size + i32.const 12 + i32.le_u + if (result i32) + i32.const 12 + else + local.get $size + i32.const 4 + i32.add + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + i32.const 4 + i32.sub + end + return + ) + (func $~lib/rt/tlsf/prepareSize (param $size i32) (result i32) + local.get $size + i32.const 1073741820 + i32.gt_u + if + i32.const 288 + i32.const 624 + i32.const 461 + i32.const 29 + call $~lib/builtins/abort + unreachable + end + local.get $size + call $~lib/rt/tlsf/computeSize + return + ) + (func $~lib/rt/tlsf/roundSize (param $size i32) (result i32) + local.get $size + i32.const 536870910 + i32.lt_u + if (result i32) + local.get $size + i32.const 1 + i32.const 27 + local.get $size + i32.clz + i32.sub + i32.shl + i32.add + i32.const 1 + i32.sub + else + local.get $size + end + return + ) + (func $~lib/rt/tlsf/searchBlock (param $root i32) (param $size i32) (result i32) + (local $fl i32) + (local $sl i32) + (local $requestSize i32) + (local $root|5 i32) + (local $fl|6 i32) + (local $slMap i32) + (local $head i32) + (local $flMap i32) + (local $root|10 i32) + (local $fl|11 i32) + (local $root|12 i32) + (local $fl|13 i32) + (local $sl|14 i32) + (local $root|15 i32) + (local $fl|16 i32) + (local $sl|17 i32) + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + call $~lib/rt/tlsf/roundSize + local.set $requestSize + i32.const 4 + i32.const 8 + i32.mul + i32.const 1 + i32.sub + local.get $requestSize + i32.clz + i32.sub + local.set $fl + local.get $requestSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 334 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETSL|inlined.2 (result i32) + local.get $root + local.set $root|5 + local.get $fl + local.set $fl|6 + local.get $root|5 + local.get $fl|6 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.2 + end + i32.const 0 + i32.const -1 + i32.xor + local.get $sl + i32.shl + i32.and + local.set $slMap + i32.const 0 + local.set $head + local.get $slMap + i32.eqz + if + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 0 + i32.const -1 + i32.xor + local.get $fl + i32.const 1 + i32.add + i32.shl + i32.and + local.set $flMap + local.get $flMap + i32.eqz + if + i32.const 0 + local.set $head + else + local.get $flMap + i32.ctz + local.set $fl + block $~lib/rt/tlsf/GETSL|inlined.3 (result i32) + local.get $root + local.set $root|10 + local.get $fl + local.set $fl|11 + local.get $root|10 + local.get $fl|11 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.3 + end + local.set $slMap + i32.const 1 + drop + local.get $slMap + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 347 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETHEAD|inlined.2 (result i32) + local.get $root + local.set $root|12 + local.get $fl + local.set $fl|13 + local.get $slMap + i32.ctz + local.set $sl|14 + local.get $root|12 + local.get $fl|13 + i32.const 4 + i32.shl + local.get $sl|14 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.2 + end + local.set $head + end + else + block $~lib/rt/tlsf/GETHEAD|inlined.3 (result i32) + local.get $root + local.set $root|15 + local.get $fl + local.set $fl|16 + local.get $slMap + i32.ctz + local.set $sl|17 + local.get $root|15 + local.get $fl|16 + i32.const 4 + i32.shl + local.get $sl|17 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.3 + end + local.set $head + end + local.get $head + return + ) + (func $~lib/rt/tlsf/growMemory (param $root i32) (param $size i32) + (local $pagesBefore i32) + (local $root|3 i32) + (local $pagesNeeded i32) + (local $5 i32) + (local $6 i32) + (local $pagesWanted i32) + (local $pagesAfter i32) + i32.const 0 + drop + local.get $size + i32.const 256 + i32.ge_u + if + local.get $size + call $~lib/rt/tlsf/roundSize + local.set $size + end + memory.size + local.set $pagesBefore + local.get $size + i32.const 4 + local.get $pagesBefore + i32.const 16 + i32.shl + i32.const 4 + i32.sub + block $~lib/rt/tlsf/GETTAIL|inlined.1 (result i32) + local.get $root + local.set $root|3 + local.get $root|3 + i32.load offset=1568 + br $~lib/rt/tlsf/GETTAIL|inlined.1 + end + i32.ne + i32.shl + i32.add + local.set $size + local.get $size + i32.const 65535 + i32.add + i32.const 65535 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.shr_u + local.set $pagesNeeded + local.get $pagesBefore + local.tee $5 + local.get $pagesNeeded + local.tee $6 + local.get $5 + local.get $6 + i32.gt_s + select + local.set $pagesWanted + local.get $pagesWanted + memory.grow + i32.const 0 + i32.lt_s + if + local.get $pagesNeeded + memory.grow + i32.const 0 + i32.lt_s + if + unreachable + end + end + memory.size + local.set $pagesAfter + local.get $root + local.get $pagesBefore + i32.const 16 + i32.shl + local.get $pagesAfter + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + drop + ) + (func $~lib/rt/tlsf/prepareBlock (param $root i32) (param $block i32) (param $size i32) + (local $blockInfo i32) + (local $remaining i32) + (local $spare i32) + (local $block|6 i32) + (local $block|7 i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $size + i32.const 4 + i32.add + i32.const 15 + i32.and + i32.eqz + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 361 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $size + i32.sub + local.set $remaining + local.get $remaining + i32.const 4 + i32.const 12 + i32.add + i32.ge_u + if + local.get $block + local.get $size + local.get $blockInfo + i32.const 2 + i32.and + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $block + i32.const 4 + i32.add + local.get $size + i32.add + local.set $spare + local.get $spare + local.get $remaining + i32.const 4 + i32.sub + i32.const 1 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.get $spare + call $~lib/rt/tlsf/insertBlock + else + local.get $block + local.get $blockInfo + i32.const 1 + i32.const -1 + i32.xor + i32.and + call $~lib/rt/common/BLOCK#set:mmInfo + block $~lib/rt/tlsf/GETRIGHT|inlined.3 (result i32) + local.get $block + local.set $block|7 + local.get $block|7 + i32.const 4 + i32.add + local.get $block|7 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.3 + end + block $~lib/rt/tlsf/GETRIGHT|inlined.2 (result i32) + local.get $block + local.set $block|6 + local.get $block|6 + i32.const 4 + i32.add + local.get $block|6 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.2 + end + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 2 + i32.const -1 + i32.xor + i32.and + call $~lib/rt/common/BLOCK#set:mmInfo + end + ) + (func $~lib/rt/tlsf/allocateBlock (param $root i32) (param $size i32) (result i32) + (local $payloadSize i32) + (local $block i32) + local.get $size + call $~lib/rt/tlsf/prepareSize + local.set $payloadSize + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/searchBlock + local.set $block + local.get $block + i32.eqz + if + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/growMemory + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/searchBlock + local.set $block + i32.const 1 + drop + local.get $block + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 499 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + end + i32.const 1 + drop + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $payloadSize + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 501 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $root + local.get $block + call $~lib/rt/tlsf/removeBlock + local.get $root + local.get $block + local.get $payloadSize + call $~lib/rt/tlsf/prepareBlock + i32.const 0 + drop + local.get $block + return + ) + (func $~lib/rt/tlsf/__alloc (param $size i32) (result i32) + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $size + call $~lib/rt/tlsf/allocateBlock + i32.const 4 + i32.add + return + ) + (func $~lib/rt/itcms/Object#set:rtId (param $this i32) (param $rtId i32) + local.get $this + local.get $rtId + i32.store offset=12 + ) + (func $~lib/rt/itcms/Object#set:rtSize (param $this i32) (param $rtSize i32) + local.get $this + local.get $rtSize + i32.store offset=16 + ) + (func $~lib/rt/itcms/__new (param $size i32) (param $id i32) (result i32) + (local $obj i32) + (local $ptr i32) + local.get $size + i32.const 1073741804 + i32.ge_u + if + i32.const 288 + i32.const 352 + i32.const 261 + i32.const 31 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.ge_u + if + call $~lib/rt/itcms/interrupt + end + i32.const 16 + local.get $size + i32.add + call $~lib/rt/tlsf/__alloc + i32.const 4 + i32.sub + local.set $obj + local.get $obj + local.get $id + call $~lib/rt/itcms/Object#set:rtId + local.get $obj + local.get $size + call $~lib/rt/itcms/Object#set:rtSize + local.get $obj + global.get $~lib/rt/itcms/fromSpace + global.get $~lib/rt/itcms/white + call $~lib/rt/itcms/Object#linkTo + global.get $~lib/rt/itcms/total + local.get $obj + call $~lib/rt/itcms/Object#get:size + i32.add + global.set $~lib/rt/itcms/total + local.get $obj + i32.const 20 + i32.add + local.set $ptr + local.get $ptr + i32.const 0 + local.get $size + memory.fill + local.get $ptr + return + ) + (func $assembly/arguments/Args#set:a (param $this i32) (param $a i32) + local.get $this + local.get $a + i32.store + ) + (func $assembly/arguments/Args#set:b (param $this i32) (param $b i32) + local.get $this + local.get $b + i32.store offset=4 + ) + (func $assembly/arguments/Args#set:c (param $this i32) (param $c i32) + local.get $this + local.get $c + i32.store offset=8 + ) + (func $assembly/arguments/Args#set:d (param $this i32) (param $d i32) + local.get $this + local.get $d + i32.store offset=12 + ) + (func $start:assembly/arguments~anonymous|0 (param $_d i32) (param $_l i32) (result i32) + i32.const 0 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + return + ) + (func $~lib/arraybuffer/ArrayBufferView#get:byteLength (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/arraybuffer/ArrayBufferView#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/itcms/__link (param $parentPtr i32) (param $childPtr i32) (param $expectMultiple i32) + (local $child i32) + (local $parent i32) + (local $parentColor i32) + local.get $childPtr + i32.eqz + if + return + end + i32.const 1 + drop + local.get $parentPtr + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 295 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $childPtr + i32.const 20 + i32.sub + local.set $child + local.get $child + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eq + if + local.get $parentPtr + i32.const 20 + i32.sub + local.set $parent + local.get $parent + call $~lib/rt/itcms/Object#get:color + local.set $parentColor + local.get $parentColor + global.get $~lib/rt/itcms/white + i32.eqz + i32.eq + if + local.get $expectMultiple + if + local.get $parent + call $~lib/rt/itcms/Object#makeGray + else + local.get $child + call $~lib/rt/itcms/Object#makeGray + end + else + local.get $parentColor + i32.const 3 + i32.eq + if (result i32) + global.get $~lib/rt/itcms/state + i32.const 1 + i32.eq + else + i32.const 0 + end + if + local.get $child + call $~lib/rt/itcms/Object#makeGray + end + end + end + ) + (func $~lib/arraybuffer/ArrayBufferView#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/arguments/Nibbles#set:low (param $this i32) (param $low i32) + local.get $this + local.get $low + i32.store8 + ) + (func $assembly/arguments/Nibbles#set:hig (param $this i32) (param $hig i32) + local.get $this + local.get $hig + i32.store8 offset=1 + ) + (func $assembly/arguments/Nibbles#get:low (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/arguments/Nibbles#get:hig (param $this i32) (result i32) + local.get $this + i32.load8_u offset=1 + ) + (func $assembly/arguments/Args#get:a (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/arguments/Args#get:b (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $start:assembly/arguments + (local $0 i32) + (local $1 i32) + (local $2 i32) + memory.size + i32.const 16 + i32.shl + global.get $~lib/memory/__heap_base + i32.sub + i32.const 1 + i32.shr_u + global.set $~lib/rt/itcms/threshold + i32.const 400 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/pinSpace + i32.const 432 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/toSpace + i32.const 576 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/fromSpace + ) + (func $assembly/instructions/Instruction#set:namePtr (param $this i32) (param $namePtr i32) + local.get $this + local.get $namePtr + i32.store + ) + (func $assembly/instructions/Instruction#set:kind (param $this i32) (param $kind i32) + local.get $this + local.get $kind + i32.store offset=4 + ) + (func $assembly/instructions/Instruction#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=8 + ) + (func $assembly/instructions/Instruction#set:isTerminating (param $this i32) (param $isTerminating i32) + local.get $this + local.get $isTerminating + i32.store8 offset=16 + ) + (func $assembly/instructions/Instruction#constructor (param $this i32) (result i32) + local.get $this + i32.eqz + if + i32.const 17 + call $~lib/rt/tlsf/__alloc + local.set $this + end + local.get $this + i32.const 0 + call $assembly/instructions/Instruction#set:namePtr + local.get $this + global.get $assembly/arguments/Arguments.Zero + call $assembly/instructions/Instruction#set:kind + local.get $this + i64.const 0 + call $assembly/instructions/Instruction#set:gas + local.get $this + i32.const 0 + call $assembly/instructions/Instruction#set:isTerminating + local.get $this + ) + (func $assembly/instructions/instruction (param $name i32) (param $kind i32) (param $gas i64) (param $isTerminating i32) (result i32) + (local $i i32) + i32.const 0 + call $assembly/instructions/Instruction#constructor + local.set $i + local.get $i + local.get $name + call $assembly/instructions/Instruction#set:namePtr + local.get $i + local.get $kind + call $assembly/instructions/Instruction#set:kind + local.get $i + local.get $gas + call $assembly/instructions/Instruction#set:gas + local.get $i + local.get $isTerminating + call $assembly/instructions/Instruction#set:isTerminating + local.get $i + return + ) + (func $~lib/rt/__newBuffer (param $size i32) (param $id i32) (param $data i32) (result i32) + (local $buffer i32) + local.get $size + local.get $id + call $~lib/rt/itcms/__new + local.set $buffer + local.get $data + if + local.get $buffer + local.get $data + local.get $size + memory.copy + end + local.get $buffer + return + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/rt/itcms/Object#get:rtSize (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $~lib/rt/itcms/__renew (param $oldPtr i32) (param $size i32) (result i32) + (local $oldObj i32) + (local $newPtr i32) + (local $4 i32) + (local $5 i32) + local.get $oldPtr + i32.const 20 + i32.sub + local.set $oldObj + local.get $size + local.get $oldObj + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.sub + i32.le_u + if + local.get $oldObj + local.get $size + call $~lib/rt/itcms/Object#set:rtSize + local.get $oldPtr + return + end + local.get $size + local.get $oldObj + call $~lib/rt/itcms/Object#get:rtId + call $~lib/rt/itcms/__new + local.set $newPtr + local.get $newPtr + local.get $oldPtr + local.get $size + local.tee $4 + local.get $oldObj + call $~lib/rt/itcms/Object#get:rtSize + local.tee $5 + local.get $4 + local.get $5 + i32.lt_u + select + memory.copy + local.get $newPtr + return + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/math/ipow32 (param $x i32) (param $e i32) (result i32) + (local $out i32) + (local $log i32) + (local $4 i32) + i32.const 1 + local.set $out + i32.const 0 + i32.const 1 + i32.lt_s + drop + local.get $x + i32.const 2 + i32.eq + if + i32.const 1 + local.get $e + i32.shl + i32.const 0 + local.get $e + i32.const 32 + i32.lt_u + select + return + end + local.get $e + i32.const 0 + i32.le_s + if + local.get $x + i32.const -1 + i32.eq + if + i32.const -1 + i32.const 1 + local.get $e + i32.const 1 + i32.and + select + return + end + local.get $e + i32.const 0 + i32.eq + local.get $x + i32.const 1 + i32.eq + i32.or + return + else + local.get $e + i32.const 1 + i32.eq + if + local.get $x + return + else + local.get $e + i32.const 2 + i32.eq + if + local.get $x + local.get $x + i32.mul + return + else + local.get $e + i32.const 32 + i32.lt_s + if + i32.const 32 + local.get $e + i32.clz + i32.sub + local.set $log + block $break|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $log + local.set $4 + local.get $4 + i32.const 5 + i32.eq + br_if $case0|0 + local.get $4 + i32.const 4 + i32.eq + br_if $case1|0 + local.get $4 + i32.const 3 + i32.eq + br_if $case2|0 + local.get $4 + i32.const 2 + i32.eq + br_if $case3|0 + local.get $4 + i32.const 1 + i32.eq + br_if $case4|0 + br $break|0 + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + end + local.get $out + return + end + end + end + end + loop $while-continue|1 + local.get $e + if + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + br $while-continue|1 + end + end + local.get $out + return + ) + (func $start:assembly/memory-page + i32.const 2 + i32.const 16 + call $~lib/math/ipow32 + global.set $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/PAGE_SIZE + i32.div_u + global.set $assembly/memory-page/RESERVED_PAGES + i32.const 2 + i32.const 29 + call $~lib/math/ipow32 + global.set $assembly/memory-page/ALLOCATE_EAGERLY + ) + (func $assembly/memory/MaybePageFault#set:isFault (param $this i32) (param $isFault i32) + local.get $this + local.get $isFault + i32.store8 + ) + (func $assembly/memory/MaybePageFault#set:isAccess (param $this i32) (param $isAccess i32) + local.get $this + local.get $isAccess + i32.store8 offset=1 + ) + (func $assembly/memory/MaybePageFault#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store offset=4 + ) + (func $~lib/arraybuffer/ArrayBufferView#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/arraybuffer/ArrayBufferView#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/arraybuffer/ArrayBufferView#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $assembly/memory-page/Page#set:access (param $this i32) (param $access i32) + local.get $this + local.get $access + i32.store + ) + (func $assembly/memory-page/Page#set:raw (param $this i32) (param $raw i32) + local.get $this + local.get $raw + i32.store offset=4 + local.get $this + local.get $raw + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory-page/RawPage#set:id (param $this i32) (param $id i32) + local.get $this + local.get $id + i32.store + ) + (func $assembly/memory-page/RawPage#set:page (param $this i32) (param $page i32) + local.get $this + local.get $page + i32.store offset=4 + local.get $this + local.get $page + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $start:assembly/instructions/outcome + call $start:assembly/memory + ) + (func $assembly/instructions/utils/reg (param $v i64) (result i32) + local.get $v + global.get $assembly/registers/NO_OF_REGISTERS + i64.extend_i32_s + i64.ge_u + if (result i32) + global.get $assembly/registers/NO_OF_REGISTERS + i32.const 1 + i32.sub + else + local.get $v + i32.wrap_i64 + end + return + ) + (func $~lib/rt/common/OBJECT#get:rtSize (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 3 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i64) + local.get $this + local.get $index + i32.const 3 + i32.shl + i32.add + local.get $value + i64.store + i32.const 0 + drop + ) + (func $assembly/instructions/outcome/OutcomeData#set:outcome (param $this i32) (param $outcome i32) + local.get $this + local.get $outcome + i32.store + ) + (func $assembly/instructions/outcome/OutcomeData#set:staticJump (param $this i32) (param $staticJump i32) + local.get $this + local.get $staticJump + i32.store offset=4 + ) + (func $assembly/instructions/outcome/OutcomeData#set:dJump (param $this i32) (param $dJump i32) + local.get $this + local.get $dJump + i32.store offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#set:result (param $this i32) (param $result i32) + local.get $this + local.get $result + i32.store offset=12 + ) + (func $assembly/instructions/outcome/OutcomeData#set:exitCode (param $this i32) (param $exitCode i32) + local.get $this + local.get $exitCode + i32.store offset=16 + ) + (func $assembly/instructions/outcome/ok (result i32) + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + return + ) + (func $assembly/instructions/utils/u8SignExtend (param $v i32) (result i64) + local.get $v + i32.extend8_s + i64.extend_i32_s + return + ) + (func $assembly/instructions/utils/u16SignExtend (param $v i32) (result i64) + local.get $v + i32.extend16_s + i64.extend_i32_s + return + ) + (func $~lib/polyfills/bswap (param $value i64) (result i64) + (local $a i64) + (local $b i64) + (local $v i64) + i32.const 1 + drop + i32.const 8 + i32.const 1 + i32.eq + drop + i32.const 8 + i32.const 2 + i32.eq + drop + i32.const 8 + i32.const 4 + i32.eq + drop + i32.const 8 + i32.const 8 + i32.eq + drop + local.get $value + i64.const 8 + i64.shr_u + i64.const 71777214294589695 + i64.and + local.set $a + local.get $value + i64.const 71777214294589695 + i64.and + i64.const 8 + i64.shl + local.set $b + local.get $a + local.get $b + i64.or + local.set $v + local.get $v + i64.const 16 + i64.shr_u + i64.const 281470681808895 + i64.and + local.set $a + local.get $v + i64.const 281470681808895 + i64.and + i64.const 16 + i64.shl + local.set $b + local.get $a + local.get $b + i64.or + i64.const 32 + i64.rotr + return + ) + (func $start:assembly/instructions/bit + call $start:assembly/instructions/outcome + ) + (func $assembly/instructions/utils/u32SignExtend (param $v i32) (result i64) + local.get $v + i64.extend_i32_s + return + ) + (func $assembly/arguments/Args#get:c (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/arguments/Args#get:d (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/memory/Chunks#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#set:first (param $this i32) (param $first i32) + local.get $this + local.get $first + i32.store offset=4 + local.get $this + local.get $first + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#set:second (param $this i32) (param $second i32) + local.get $this + local.get $second + i32.store offset=8 + local.get $this + local.get $second + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Memory#get:pages (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/util/hash/HASH (param $key i32) (result i32) + (local $key|1 i32) + (local $len i32) + (local $h i32) + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 4 + i32.const 4 + i32.le_u + drop + block $~lib/util/hash/hash32|inlined.0 (result i32) + local.get $key + local.set $key|1 + i32.const 4 + local.set $len + i32.const 0 + i32.const 374761393 + i32.add + local.get $len + i32.add + local.set $h + local.get $h + local.get $key|1 + i32.const -1028477379 + i32.mul + i32.add + local.set $h + local.get $h + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 15 + i32.shr_u + i32.xor + local.set $h + local.get $h + i32.const -2048144777 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 13 + i32.shr_u + i32.xor + local.set $h + local.get $h + i32.const -1028477379 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 16 + i32.shr_u + i32.xor + local.set $h + local.get $h + br $~lib/util/hash/hash32|inlined.0 + end + return + ) + (func $"~lib/map/Map#get:buckets" (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $"~lib/map/Map#get:bucketsMask" (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $"~lib/map/MapEntry#get:taggedNext" (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#get:key" (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/PageData#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/PageData#set:page (param $this i32) (param $page i32) + local.get $this + local.get $page + i32.store offset=4 + local.get $this + local.get $page + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/PageData#set:relativeAddress (param $this i32) (param $relativeAddress i32) + local.get $this + local.get $relativeAddress + i32.store offset=8 + ) + (func $"~lib/map/MapEntry#get:value" (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Page#get:access (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/PageData#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/MaybePageFault#get:isFault (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/memory/PageData#get:page (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/PageData#get:relativeAddress (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/memory-page/Page#get:raw (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/RawPage#get:page (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i32) (param $start i32) (param $end i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + local.get $start + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $start + i32.add + local.tee $5 + i32.const 0 + local.tee $6 + local.get $5 + local.get $6 + i32.gt_u + select + else + local.get $start + local.tee $7 + local.get $len + local.tee $8 + local.get $7 + local.get $8 + i32.lt_s + select + end + local.set $start + local.get $end + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $end + i32.add + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_u + select + else + local.get $end + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + end + local.set $end + i32.const 1 + i32.const 1 + i32.eq + drop + local.get $start + local.get $end + i32.lt_s + if + local.get $ptr + local.get $start + i32.add + local.get $value + local.get $end + local.get $start + i32.sub + memory.fill + end + ) + (func $assembly/memory/Chunks#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/ChunkBytes#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/ChunkBytes#set:bytes (param $this i32) (param $bytes i32) + local.get $this + local.get $bytes + i32.store offset=4 + local.get $this + local.get $bytes + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#get:first (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/Chunks#get:second (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 0 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + i32.const 0 + drop + ) + (func $assembly/memory/Result#set:ok (param $this i32) (param $ok i64) + local.get $this + local.get $ok + i64.store + ) + (func $assembly/memory/Result#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store offset=8 + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/ChunkBytes#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/ChunkBytes#get:bytes (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/Result#get:fault (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/memory/Result#get:ok (param $this i32) (result i64) + local.get $this + i64.load + ) + (func $assembly/memory/MaybePageFault#get:isAccess (param $this i32) (result i32) + local.get $this + i32.load8_u offset=1 + ) + (func $assembly/memory/MaybePageFault#get:fault (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/math/ipow64 (param $x i64) (param $e i64) (result i64) + (local $out i64) + (local $log i32) + (local $4 i32) + i64.const 1 + local.set $out + i32.const 0 + i32.const 1 + i32.lt_s + drop + local.get $x + i64.const 2 + i64.eq + if + i64.const 1 + local.get $e + i64.shl + i64.const 0 + local.get $e + i64.const 64 + i64.lt_u + select + return + end + local.get $e + i64.const 0 + i64.le_s + if + local.get $x + i64.const -1 + i64.eq + if + i64.const -1 + i64.const 1 + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + select + return + end + local.get $e + i64.const 0 + i64.eq + i64.extend_i32_u + local.get $x + i64.const 1 + i64.eq + i64.extend_i32_u + i64.or + return + else + local.get $e + i64.const 1 + i64.eq + if + local.get $x + return + else + local.get $e + i64.const 2 + i64.eq + if + local.get $x + local.get $x + i64.mul + return + else + local.get $e + i64.const 64 + i64.lt_s + if + i32.const 64 + local.get $e + i64.clz + i32.wrap_i64 + i32.sub + local.set $log + block $break|0 + block $case5|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $log + local.set $4 + local.get $4 + i32.const 6 + i32.eq + br_if $case0|0 + local.get $4 + i32.const 5 + i32.eq + br_if $case1|0 + local.get $4 + i32.const 4 + i32.eq + br_if $case2|0 + local.get $4 + i32.const 3 + i32.eq + br_if $case3|0 + local.get $4 + i32.const 2 + i32.eq + br_if $case4|0 + local.get $4 + i32.const 1 + i32.eq + br_if $case5|0 + br $break|0 + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + end + local.get $out + return + end + end + end + end + loop $while-continue|1 + local.get $e + i64.const 0 + i64.ne + if + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + br $while-continue|1 + end + end + local.get $out + return + ) + (func $assembly/instructions/utils/mulUpperUnsigned (param $a i64) (param $b i64) (result i64) + (local $aHigh i64) + (local $aLow i64) + (local $bHigh i64) + (local $bLow i64) + (local $lowLow i64) + (local $lowHigh i64) + (local $highLow i64) + (local $highHigh i64) + (local $carry i64) + local.get $a + i64.const 32 + i64.shr_u + local.set $aHigh + local.get $a + i64.const 4294967295 + i64.and + local.set $aLow + local.get $b + i64.const 32 + i64.shr_u + local.set $bHigh + local.get $b + i64.const 4294967295 + i64.and + local.set $bLow + local.get $aLow + local.get $bLow + i64.mul + local.set $lowLow + local.get $aLow + local.get $bHigh + i64.mul + local.set $lowHigh + local.get $aHigh + local.get $bLow + i64.mul + local.set $highLow + local.get $aHigh + local.get $bHigh + i64.mul + local.set $highHigh + local.get $lowLow + i64.const 32 + i64.shr_u + local.get $lowHigh + i64.const 4294967295 + i64.and + i64.add + local.get $highLow + i64.const 4294967295 + i64.and + i64.add + local.set $carry + local.get $highHigh + local.get $lowHigh + i64.const 32 + i64.shr_u + i64.add + local.get $highLow + i64.const 32 + i64.shr_u + i64.add + local.get $carry + i64.const 32 + i64.shr_u + i64.add + return + ) + (func $assembly/instructions/utils/mulUpperSigned (param $a i64) (param $b i64) (result i64) + (local $isResultNegative i32) + (local $aAbs i64) + (local $bAbs i64) + (local $upper i64) + (local $lower i64) + i32.const 0 + local.set $isResultNegative + local.get $a + local.set $aAbs + local.get $b + local.set $bAbs + local.get $a + i64.const 0 + i64.lt_s + if + local.get $isResultNegative + i32.eqz + local.set $isResultNegative + local.get $a + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $aAbs + end + local.get $b + i64.const 0 + i64.lt_s + if + local.get $isResultNegative + i32.eqz + local.set $isResultNegative + local.get $b + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $bAbs + end + local.get $isResultNegative + if + local.get $aAbs + local.get $bAbs + call $assembly/instructions/utils/mulUpperUnsigned + local.set $upper + local.get $aAbs + local.get $bAbs + i64.mul + local.set $lower + local.get $upper + i64.const -1 + i64.xor + local.get $lower + i64.const 0 + i64.eq + if (result i64) + i64.const 1 + else + i64.const 0 + end + i64.add + return + end + local.get $aAbs + local.get $bAbs + call $assembly/instructions/utils/mulUpperUnsigned + return + ) + (func $assembly/instructions/utils/mulUpperSignedUnsigned (param $a i64) (param $b i64) (result i64) + (local $aAbs i64) + (local $upper i64) + (local $lower i64) + local.get $a + i64.const 0 + i64.lt_s + if + local.get $a + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $aAbs + local.get $aAbs + local.get $b + call $assembly/instructions/utils/mulUpperUnsigned + local.set $upper + local.get $aAbs + local.get $b + i64.mul + local.set $lower + local.get $upper + i64.const -1 + i64.xor + local.get $lower + i64.const 0 + i64.eq + if (result i64) + i64.const 1 + else + i64.const 0 + end + i64.add + return + end + local.get $a + local.get $b + call $assembly/instructions/utils/mulUpperUnsigned + return + ) + (func $assembly/instructions/rot/math.rot_r (param $v i64) (param $shift i64) (result i64) + local.get $v + local.get $shift + i64.rotr + return + ) + (func $assembly/instructions/rot/math.rot_r_32 (param $v i32) (param $shift i32) (result i32) + local.get $v + local.get $shift + i32.rotr + return + ) + (func $assembly/instructions/rot/math.rot_l (param $v i64) (param $shift i64) (result i64) + local.get $v + local.get $shift + i64.rotl + return + ) + (func $assembly/instructions/rot/math.rot_l_32 (param $v i32) (param $shift i32) (result i32) + local.get $v + local.get $shift + i32.rotl + return + ) + (func $assembly/instructions/outcome/panic (result i32) + global.get $assembly/instructions/outcome/Result.PANIC + call $assembly/instructions/outcome/status + return + ) + (func $start:assembly/instructions/misc~anonymous|0 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/panic + ) + (func $start:assembly/instructions/misc~anonymous|1 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/panic + ) + (func $start:assembly/instructions/misc~anonymous|2 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/ok + ) + (func $assembly/memory/Memory#get:sbrkAddress (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/memory/Memory#set:sbrkAddress (param $this i32) (param $sbrkAddress i32) + local.get $this + local.get $sbrkAddress + i32.store offset=12 + ) + (func $assembly/memory/Memory#get:lastAllocatedPage (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/Memory#get:arena (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Arena#get:free (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $assembly/memory-page/Arena#get:extraPageIndex (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/memory-page/Arena#get:arenaBytes (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Arena#set:extraPageIndex (param $this i32) (param $extraPageIndex i32) + local.get $this + local.get $extraPageIndex + i32.store offset=8 + ) + (func $"~lib/map/MapEntry#set:value" (param $this i32) (param $value i32) + local.get $this + local.get $value + i32.store offset=4 + ) + (func $"~lib/map/Map#get:entriesOffset" (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $"~lib/map/Map#get:entriesCapacity" (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $"~lib/map/Map#get:entriesCount" (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $"~lib/map/Map#get:entries" (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#set:key" (param $this i32) (param $key i32) + local.get $this + local.get $key + i32.store + ) + (func $"~lib/map/MapEntry#set:taggedNext" (param $this i32) (param $taggedNext i32) + local.get $this + local.get $taggedNext + i32.store offset=8 + ) + (func $"~lib/map/Map#set:buckets" (param $this i32) (param $buckets i32) + local.get $this + local.get $buckets + i32.store + local.get $this + local.get $buckets + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $"~lib/map/Map#set:bucketsMask" (param $this i32) (param $bucketsMask i32) + local.get $this + local.get $bucketsMask + i32.store offset=4 + ) + (func $"~lib/map/Map#set:entries" (param $this i32) (param $entries i32) + local.get $this + local.get $entries + i32.store offset=8 + local.get $this + local.get $entries + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $"~lib/map/Map#set:entriesCapacity" (param $this i32) (param $entriesCapacity i32) + local.get $this + local.get $entriesCapacity + i32.store offset=12 + ) + (func $"~lib/map/Map#set:entriesOffset" (param $this i32) (param $entriesOffset i32) + local.get $this + local.get $entriesOffset + i32.store offset=16 + ) + (func $"~lib/map/Map#set:entriesCount" (param $this i32) (param $entriesCount i32) + local.get $this + local.get $entriesCount + i32.store offset=20 + ) + (func $assembly/memory/Memory#set:lastAllocatedPage (param $this i32) (param $lastAllocatedPage i32) + local.get $this + local.get $lastAllocatedPage + i32.store + ) + (func $start:assembly/instructions-exe + (local $0 i32) + call $start:assembly/instructions/bit + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $start:assembly/interpreter + call $start:assembly/instructions-exe + i64.const 2 + i64.const 32 + call $~lib/math/ipow64 + global.set $assembly/interpreter/MAX_U32 + ) + (func $start:assembly/api-generic + call $start:assembly/arguments + call $start:assembly/instructions + call $start:assembly/interpreter + ) + (func $start:assembly/index + call $start:assembly/api-generic + ) + (func $assembly/codec/Decoder#set:source (param $this i32) (param $source i32) + local.get $this + local.get $source + i32.store + local.get $this + local.get $source + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/codec/Decoder#set:offset (param $this i32) (param $offset i32) + local.get $this + local.get $offset + i32.store offset=4 + ) + (func $assembly/codec/Decoder#get:offset (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/codec/Decoder#get:source (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/util/number/decimalCount32 (param $value i32) (result i32) + local.get $value + i32.const 100000 + i32.lt_u + if + local.get $value + i32.const 100 + i32.lt_u + if + i32.const 1 + local.get $value + i32.const 10 + i32.ge_u + i32.add + return + else + i32.const 3 + local.get $value + i32.const 10000 + i32.ge_u + i32.add + local.get $value + i32.const 1000 + i32.ge_u + i32.add + return + end + unreachable + else + local.get $value + i32.const 10000000 + i32.lt_u + if + i32.const 6 + local.get $value + i32.const 1000000 + i32.ge_u + i32.add + return + else + i32.const 8 + local.get $value + i32.const 1000000000 + i32.ge_u + i32.add + local.get $value + i32.const 100000000 + i32.ge_u + i32.add + return + end + unreachable + end + unreachable + ) + (func $~lib/util/number/utoa32_dec_lut (param $buffer i32) (param $num i32) (param $offset i32) + (local $t i32) + (local $r i32) + (local $d1 i32) + (local $d2 i32) + (local $digits1 i64) + (local $digits2 i64) + (local $t|9 i32) + (local $d1|10 i32) + (local $digits i32) + (local $digits|12 i32) + (local $digit i32) + loop $while-continue|0 + local.get $num + i32.const 10000 + i32.ge_u + if + local.get $num + i32.const 10000 + i32.div_u + local.set $t + local.get $num + i32.const 10000 + i32.rem_u + local.set $r + local.get $t + local.set $num + local.get $r + i32.const 100 + i32.div_u + local.set $d1 + local.get $r + i32.const 100 + i32.rem_u + local.set $d2 + i32.const 14812 + local.get $d1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 14812 + local.get $d2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $num + i32.const 100 + i32.ge_u + if + local.get $num + i32.const 100 + i32.div_u + local.set $t|9 + local.get $num + i32.const 100 + i32.rem_u + local.set $d1|10 + local.get $t|9 + local.set $num + local.get $offset + i32.const 2 + i32.sub + local.set $offset + i32.const 14812 + local.get $d1|10 + i32.const 2 + i32.shl + i32.add + i32.load + local.set $digits + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits + i32.store + end + local.get $num + i32.const 10 + i32.ge_u + if + local.get $offset + i32.const 2 + i32.sub + local.set $offset + i32.const 14812 + local.get $num + i32.const 2 + i32.shl + i32.add + i32.load + local.set $digits|12 + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits|12 + i32.store + else + local.get $offset + i32.const 1 + i32.sub + local.set $offset + i32.const 48 + local.get $num + i32.add + local.set $digit + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digit + i32.store16 + end + ) + (func $~lib/util/number/utoa_hex_lut (param $buffer i32) (param $num i64) (param $offset i32) + loop $while-continue|0 + local.get $offset + i32.const 2 + i32.ge_u + if + local.get $offset + i32.const 2 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 15232 + local.get $num + i32.wrap_i64 + i32.const 255 + i32.and + i32.const 2 + i32.shl + i32.add + i32.load + i32.store + local.get $num + i64.const 8 + i64.shr_u + local.set $num + br $while-continue|0 + end + end + local.get $offset + i32.const 1 + i32.and + if + local.get $buffer + i32.const 15232 + local.get $num + i32.wrap_i64 + i32.const 6 + i32.shl + i32.add + i32.load16_u + i32.store16 + end + ) + (func $~lib/util/number/ulog_base (param $num i64) (param $base i32) (result i32) + (local $value i32) + (local $b64 i64) + (local $b i64) + (local $e i32) + block $~lib/util/number/isPowerOf2|inlined.0 (result i32) + local.get $base + local.set $value + local.get $value + i32.popcnt + i32.const 1 + i32.eq + br $~lib/util/number/isPowerOf2|inlined.0 + end + if + i32.const 63 + local.get $num + i64.clz + i32.wrap_i64 + i32.sub + i32.const 31 + local.get $base + i32.clz + i32.sub + i32.div_u + i32.const 1 + i32.add + return + end + local.get $base + i64.extend_i32_s + local.set $b64 + local.get $b64 + local.set $b + i32.const 1 + local.set $e + loop $while-continue|0 + local.get $num + local.get $b + i64.ge_u + if + local.get $num + local.get $b + i64.div_u + local.set $num + local.get $b + local.get $b + i64.mul + local.set $b + local.get $e + i32.const 1 + i32.shl + local.set $e + br $while-continue|0 + end + end + loop $while-continue|1 + local.get $num + i64.const 1 + i64.ge_u + if + local.get $num + local.get $b64 + i64.div_u + local.set $num + local.get $e + i32.const 1 + i32.add + local.set $e + br $while-continue|1 + end + end + local.get $e + i32.const 1 + i32.sub + return + ) + (func $~lib/util/number/utoa64_any_core (param $buffer i32) (param $num i64) (param $offset i32) (param $radix i32) + (local $base i64) + (local $shift i64) + (local $mask i64) + (local $q i64) + local.get $radix + i64.extend_i32_s + local.set $base + local.get $radix + local.get $radix + i32.const 1 + i32.sub + i32.and + i32.const 0 + i32.eq + if + local.get $radix + i32.ctz + i32.const 7 + i32.and + i64.extend_i32_s + local.set $shift + local.get $base + i64.const 1 + i64.sub + local.set $mask + loop $do-loop|0 + local.get $offset + i32.const 1 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 16288 + local.get $num + local.get $mask + i64.and + i32.wrap_i64 + i32.const 1 + i32.shl + i32.add + i32.load16_u + i32.store16 + local.get $num + local.get $shift + i64.shr_u + local.set $num + local.get $num + i64.const 0 + i64.ne + br_if $do-loop|0 + end + else + loop $do-loop|1 + local.get $offset + i32.const 1 + i32.sub + local.set $offset + local.get $num + local.get $base + i64.div_u + local.set $q + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 16288 + local.get $num + local.get $q + local.get $base + i64.mul + i64.sub + i32.wrap_i64 + i32.const 1 + i32.shl + i32.add + i32.load16_u + i32.store16 + local.get $q + local.set $num + local.get $num + i64.const 0 + i64.ne + br_if $do-loop|1 + end + end + ) + (func $~lib/number/U32#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/utoa32 + return + ) + (func $~lib/number/I32#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/itoa32 + return + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/string/String#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 1 + i32.shr_u + return + ) + (func $assembly/codec/ValOffset#set:value (param $this i32) (param $value i32) + local.get $this + local.get $value + i32.store + ) + (func $assembly/codec/ValOffset#set:offset (param $this i32) (param $offset i32) + local.get $this + local.get $offset + i32.store offset=4 + ) + (func $assembly/codec/ValOffset#get:offset (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/codec/ValOffset#get:value (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/CodeAndMetadata#set:code (param $this i32) (param $code i32) + local.get $this + local.get $code + i32.store + local.get $this + local.get $code + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/CodeAndMetadata#set:metadata (param $this i32) (param $metadata i32) + local.get $this + local.get $metadata + i32.store offset=4 + local.get $this + local.get $metadata + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/CodeAndMetadata#get:code (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/CodeAndMetadata#get:metadata (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/number/U8#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + i32.const 255 + i32.and + local.get $radix + call $~lib/util/number/utoa32 + return + ) + (func $~lib/memory/memory.repeat (param $dst i32) (param $src i32) (param $srcLength i32) (param $count i32) + (local $index i32) + (local $total i32) + i32.const 0 + local.set $index + local.get $srcLength + local.get $count + i32.mul + local.set $total + loop $while-continue|0 + local.get $index + local.get $total + i32.lt_u + if + local.get $dst + local.get $index + i32.add + local.get $src + local.get $srcLength + memory.copy + local.get $index + local.get $srcLength + i32.add + local.set $index + br $while-continue|0 + end + end + ) + (func $assembly/program/Mask#set:bytesToSkip (param $this i32) (param $bytesToSkip i32) + local.get $this + local.get $bytesToSkip + i32.store + local.get $this + local.get $bytesToSkip + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Mask#get:bytesToSkip (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + ) + (func $assembly/program/JumpTable#set:jumps (param $this i32) (param $jumps i32) + local.get $this + local.get $jumps + i32.store + local.get $this + local.get $jumps + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + ) + (func $assembly/instructions/Instruction#get:isTerminating (param $this i32) (result i32) + local.get $this + i32.load8_u offset=16 + ) + (func $assembly/program/BasicBlocks#set:isStartOrEnd (param $this i32) (param $isStartOrEnd i32) + local.get $this + local.get $isStartOrEnd + i32.store + local.get $this + local.get $isStartOrEnd + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:code (param $this i32) (param $code i32) + local.get $this + local.get $code + i32.store + local.get $this + local.get $code + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:mask (param $this i32) (param $mask i32) + local.get $this + local.get $mask + i32.store offset=4 + local.get $this + local.get $mask + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:jumpTable (param $this i32) (param $jumpTable i32) + local.get $this + local.get $jumpTable + i32.store offset=8 + local.get $this + local.get $jumpTable + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:basicBlocks (param $this i32) (param $basicBlocks i32) + local.get $this + local.get $basicBlocks + i32.store offset=12 + local.get $this + local.get $basicBlocks + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#get:code (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/Program#get:mask (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/Instruction#get:namePtr (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/instructions/Instruction#get:kind (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i64) (param $start i32) (param $end i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + local.get $start + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $start + i32.add + local.tee $5 + i32.const 0 + local.tee $6 + local.get $5 + local.get $6 + i32.gt_u + select + else + local.get $start + local.tee $7 + local.get $len + local.tee $8 + local.get $7 + local.get $8 + i32.lt_s + select + end + local.set $start + local.get $end + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $end + i32.add + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_u + select + else + local.get $end + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + end + local.set $end + i32.const 8 + i32.const 1 + i32.eq + drop + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 1 + drop + local.get $value + i64.const 0 + i64.eq + local.get $value + i64.const -1 + i64.eq + i32.or + if + local.get $start + local.get $end + i32.lt_s + if + local.get $ptr + local.get $start + i32.const 3 + i32.shl + i32.add + local.get $value + i32.wrap_i64 + local.get $end + local.get $start + i32.sub + i32.const 3 + i32.shl + memory.fill + end + return + end + loop $for-loop|0 + local.get $start + local.get $end + i32.lt_s + if + local.get $ptr + local.get $start + i32.const 3 + i32.shl + i32.add + local.get $value + i64.store + local.get $start + i32.const 1 + i32.add + local.set $start + br $for-loop|0 + end + end + ) + (func $assembly/api-generic/VmInput#set:registers (param $this i32) (param $registers i32) + local.get $this + local.get $registers + i32.store + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmInput#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store offset=4 + ) + (func $assembly/api-generic/VmInput#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=8 + ) + (func $assembly/api-generic/VmInput#set:program (param $this i32) (param $program i32) + local.get $this + local.get $program + i32.store offset=16 + local.get $this + local.get $program + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmInput#set:pageMap (param $this i32) (param $pageMap i32) + local.get $this + local.get $pageMap + i32.store offset=20 + local.get $this + local.get $pageMap + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmInput#set:memory (param $this i32) (param $memory i32) + local.get $this + local.get $memory + i32.store offset=24 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmInput#get:program (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/api-generic/VmInput#get:registers (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/MemoryBuilder#set:pages (param $this i32) (param $pages i32) + local.get $this + local.get $pages + i32.store + local.get $this + local.get $pages + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory-page/Arena#set:arenaBytes (param $this i32) (param $arenaBytes i32) + local.get $this + local.get $arenaBytes + i32.store offset=4 + ) + (func $assembly/memory-page/Arena#set:free (param $this i32) (param $free i32) + local.get $this + local.get $free + i32.store + local.get $this + local.get $free + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/arraybuffer/ArrayBuffer#get:byteLength (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + return + ) + (func $assembly/memory/MemoryBuilder#set:arena (param $this i32) (param $arena i32) + local.get $this + local.get $arena + i32.store offset=4 + local.get $this + local.get $arena + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmInput#get:pageMap (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $assembly/api-generic/VmInput#get:memory (param $this i32) (result i32) + local.get $this + i32.load offset=24 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-generic/InitialPage#get:access (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/api-generic/InitialPage#get:address (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/api-generic/InitialPage#get:length (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/MemoryBuilder#get:pages (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/MemoryBuilder#get:arena (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-generic/InitialChunk#get:data (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-generic/InitialChunk#get:address (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/Memory#set:arena (param $this i32) (param $arena i32) + local.get $this + local.get $arena + i32.store offset=4 + local.get $this + local.get $arena + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Memory#set:pages (param $this i32) (param $pages i32) + local.get $this + local.get $pages + i32.store offset=8 + local.get $this + local.get $pages + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/interpreter/Interpreter#set:program (param $this i32) (param $program i32) + local.get $this + local.get $program + i32.store + local.get $this + local.get $program + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/interpreter/Interpreter#set:registers (param $this i32) (param $registers i32) + local.get $this + local.get $registers + i32.store offset=4 + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/interpreter/Interpreter#set:memory (param $this i32) (param $memory i32) + local.get $this + local.get $memory + i32.store offset=8 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/gas/GasCounterU64#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store + ) + (func $assembly/gas/gasCounter (param $gas i64) (result i32) + i32.const 0 + local.get $gas + call $assembly/gas/GasCounterU64#constructor + return + ) + (func $assembly/interpreter/Interpreter#set:gas (param $this i32) (param $gas i32) + local.get $this + local.get $gas + i32.store offset=12 + local.get $this + local.get $gas + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/interpreter/Interpreter#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store offset=16 + ) + (func $assembly/interpreter/Interpreter#set:status (param $this i32) (param $status i32) + local.get $this + local.get $status + i32.store offset=20 + ) + (func $assembly/interpreter/Interpreter#set:exitCode (param $this i32) (param $exitCode i32) + local.get $this + local.get $exitCode + i32.store offset=24 + ) + (func $assembly/interpreter/Interpreter#set:nextPc (param $this i32) (param $nextPc i32) + local.get $this + local.get $nextPc + i32.store offset=28 + ) + (func $assembly/interpreter/Interpreter#set:useSbrkGas (param $this i32) (param $useSbrkGas i32) + local.get $this + local.get $useSbrkGas + i32.store8 offset=32 + ) + (func $assembly/api-generic/VmInput#get:pc (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/interpreter/Interpreter#get:gas (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/api-generic/VmInput#get:gas (param $this i32) (result i64) + local.get $this + i64.load offset=8 + ) + (func $assembly/gas/GasCounter#set (param $this i32) (param $g i64) + unreachable + ) + (func $~lib/util/number/decimalCount64High (param $value i64) (result i32) + local.get $value + i64.const 1000000000000000 + i64.lt_u + if + local.get $value + i64.const 1000000000000 + i64.lt_u + if + i32.const 10 + local.get $value + i64.const 100000000000 + i64.ge_u + i32.add + local.get $value + i64.const 10000000000 + i64.ge_u + i32.add + return + else + i32.const 13 + local.get $value + i64.const 100000000000000 + i64.ge_u + i32.add + local.get $value + i64.const 10000000000000 + i64.ge_u + i32.add + return + end + unreachable + else + local.get $value + i64.const 100000000000000000 + i64.lt_u + if + i32.const 16 + local.get $value + i64.const 10000000000000000 + i64.ge_u + i32.add + return + else + i32.const 18 + local.get $value + i64.const -8446744073709551616 + i64.ge_u + i32.add + local.get $value + i64.const 1000000000000000000 + i64.ge_u + i32.add + return + end + unreachable + end + unreachable + ) + (func $~lib/util/number/utoa64_dec_lut (param $buffer i32) (param $num i64) (param $offset i32) + (local $t i64) + (local $r i32) + (local $b i32) + (local $c i32) + (local $b1 i32) + (local $b2 i32) + (local $c1 i32) + (local $c2 i32) + (local $digits1 i64) + (local $digits2 i64) + loop $while-continue|0 + local.get $num + i64.const 100000000 + i64.ge_u + if + local.get $num + i64.const 100000000 + i64.div_u + local.set $t + local.get $num + local.get $t + i64.const 100000000 + i64.mul + i64.sub + i32.wrap_i64 + local.set $r + local.get $t + local.set $num + local.get $r + i32.const 10000 + i32.div_u + local.set $b + local.get $r + i32.const 10000 + i32.rem_u + local.set $c + local.get $b + i32.const 100 + i32.div_u + local.set $b1 + local.get $b + i32.const 100 + i32.rem_u + local.set $b2 + local.get $c + i32.const 100 + i32.div_u + local.set $c1 + local.get $c + i32.const 100 + i32.rem_u + local.set $c2 + i32.const 14812 + local.get $c1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 14812 + local.get $c2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + i32.const 14812 + local.get $b1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 14812 + local.get $b2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $buffer + local.get $num + i32.wrap_i64 + local.get $offset + call $~lib/util/number/utoa32_dec_lut + ) + (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i64) (result i32) + (local $sign i32) + (local $dest i32) + (local $decimals i32) + (local $val32 i32) + (local $buffer|6 i32) + (local $num i32) + (local $offset i32) + (local $val64 i64) + (local $buffer|10 i32) + (local $num|11 i64) + (local $offset|12 i32) + i32.const 0 + local.set $sign + i32.const 0 + drop + local.get $buffer + local.get $sign + i32.const 1 + i32.shl + i32.add + local.set $dest + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 0 + drop + local.get $value + i64.const 10 + i64.lt_u + if + local.get $buffer + local.get $value + i32.const 48 + i64.extend_i32_s + i64.or + i64.store16 + i32.const 1 + return + end + i32.const 0 + local.set $decimals + i32.const 8 + i32.const 4 + i32.le_u + drop + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + local.get $dest + local.set $buffer|6 + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|6 + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + local.set $val64 + local.get $val64 + call $~lib/util/number/decimalCount64High + local.set $decimals + local.get $dest + local.set $buffer|10 + local.get $val64 + local.set $num|11 + local.get $decimals + local.set $offset|12 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|10 + local.get $num|11 + local.get $offset|12 + call $~lib/util/number/utoa64_dec_lut + end + local.get $sign + local.get $decimals + i32.add + return + ) + (func $~lib/number/U64#toString (param $this i64) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/utoa64 + return + ) + (func $~lib/array/Array<~lib/string/String>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array<~lib/string/String>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/interpreter/Interpreter#get:status (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $assembly/interpreter/Interpreter#get:pc (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/interpreter/Interpreter#get:program (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/interpreter/Interpreter#get:registers (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/program/ResolvedArguments#set:a (param $this i32) (param $a i64) + local.get $this + local.get $a + i64.store + ) + (func $assembly/program/ResolvedArguments#set:b (param $this i32) (param $b i64) + local.get $this + local.get $b + i64.store offset=8 + ) + (func $assembly/program/ResolvedArguments#set:c (param $this i32) (param $c i64) + local.get $this + local.get $c + i64.store offset=16 + ) + (func $assembly/program/ResolvedArguments#set:d (param $this i32) (param $d i64) + local.get $this + local.get $d + i64.store offset=24 + ) + (func $assembly/program/ResolvedArguments#set:decoded (param $this i32) (param $decoded i32) + local.get $this + local.get $decoded + i32.store offset=32 + local.get $this + local.get $decoded + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/ResolvedArguments#get:a (param $this i32) (result i64) + local.get $this + i64.load + ) + (func $~lib/number/I64#toString (param $this i64) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/itoa64 + return + ) + (func $assembly/program/ResolvedArguments#get:decoded (param $this i32) (result i32) + local.get $this + i32.load offset=32 + ) + (func $assembly/program/ResolvedArguments#get:b (param $this i32) (result i64) + local.get $this + i64.load offset=8 + ) + (func $assembly/program/ResolvedArguments#get:c (param $this i32) (result i64) + local.get $this + i64.load offset=16 + ) + (func $assembly/program/ResolvedArguments#get:d (param $this i32) (result i64) + local.get $this + i64.load offset=24 + ) + (func $assembly/interpreter/Interpreter#get:nextPc (param $this i32) (result i32) + local.get $this + i32.load offset=28 + ) + (func $assembly/instructions/Instruction#get:gas (param $this i32) (result i64) + local.get $this + i64.load offset=8 + ) + (func $assembly/gas/GasCounter#sub (param $this i32) (param $g i64) (result i32) + unreachable + ) + (func $assembly/interpreter/Interpreter#get:useSbrkGas (param $this i32) (result i32) + local.get $this + i32.load8_u offset=32 + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/interpreter/Interpreter#get:memory (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#get:outcome (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/Program#get:jumpTable (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#get:dJump (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/interpreter/DjumpResult#set:status (param $this i32) (param $status i32) + local.get $this + local.get $status + i32.store + ) + (func $assembly/interpreter/DjumpResult#set:newPc (param $this i32) (param $newPc i32) + local.get $this + local.get $newPc + i32.store offset=4 + ) + (func $assembly/program/JumpTable#get:jumps (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/interpreter/DjumpResult#get:status (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/Program#get:basicBlocks (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/interpreter/DjumpResult#get:newPc (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/interpreter/BranchResult#set:isOkay (param $this i32) (param $isOkay i32) + local.get $this + local.get $isOkay + i32.store8 + ) + (func $assembly/interpreter/BranchResult#set:newPc (param $this i32) (param $newPc i32) + local.get $this + local.get $newPc + i32.store offset=4 + ) + (func $assembly/program/BasicBlocks#get:isStartOrEnd (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/interpreter/BranchResult#get:isOkay (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/interpreter/BranchResult#get:newPc (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/outcome/OutcomeData#get:staticJump (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/outcome/OutcomeData#get:result (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/instructions/outcome/OutcomeData#get:exitCode (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/api-generic/VmOutput#set:status (param $this i32) (param $status i32) + local.get $this + local.get $status + i32.store + ) + (func $assembly/api-generic/VmOutput#set:registers (param $this i32) (param $registers i32) + local.get $this + local.get $registers + i32.store offset=4 + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmOutput#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store offset=8 + ) + (func $assembly/api-generic/VmOutput#set:memory (param $this i32) (param $memory i32) + local.get $this + local.get $memory + i32.store offset=12 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-generic/VmOutput#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=16 + ) + (func $assembly/api-generic/VmOutput#set:exitCode (param $this i32) (param $exitCode i32) + local.get $this + local.get $exitCode + i32.store offset=24 + ) + (func $assembly/gas/GasCounter#get (param $this i32) (result i64) + unreachable + ) + (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $assembly/api-generic/InitialChunk#set:address (param $this i32) (param $address i32) + local.get $this + local.get $address + i32.store + ) + (func $assembly/api-generic/InitialChunk#set:data (param $this i32) (param $data i32) + local.get $this + local.get $data + i32.store offset=4 + local.get $this + local.get $data + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $assembly/interpreter/Interpreter#get:exitCode (param $this i32) (result i32) + local.get $this + i32.load offset=24 + ) + (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-generic/VmOutput#get:status (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 0 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + i32.const 0 + drop + ) + (func $assembly/program-build/immBytes (param $dataLength i32) (param $required i32) (result i32) + (local $value1 f64) + (local $value2 f64) + local.get $dataLength + local.get $required + i32.lt_s + if + i32.const 0 + return + end + block $~lib/math/NativeMath.min|inlined.4 (result f64) + f64.const 4 + local.set $value1 + local.get $dataLength + local.get $required + i32.sub + f64.convert_i32_s + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.4 + end + i32.trunc_sat_f64_s + return + ) + (func $~lib/dataview/DataView#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/dataview/DataView#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/dataview/DataView#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $~lib/dataview/DataView#get:byteLength (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/dataview/DataView#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-generic/InitialPage#set:address (param $this i32) (param $address i32) + local.get $this + local.get $address + i32.store + ) + (func $assembly/api-generic/InitialPage#set:length (param $this i32) (param $length i32) + local.get $this + local.get $length + i32.store offset=4 + ) + (func $assembly/api-generic/InitialPage#set:access (param $this i32) (param $access i32) + local.get $this + local.get $access + i32.store offset=8 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/rt/itcms/__pin (param $ptr i32) (result i32) + (local $obj i32) + local.get $ptr + if + local.get $ptr + i32.const 20 + i32.sub + local.set $obj + local.get $obj + call $~lib/rt/itcms/Object#get:color + i32.const 3 + i32.eq + if + i32.const 19920 + i32.const 352 + i32.const 338 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $obj + call $~lib/rt/itcms/Object#unlink + local.get $obj + global.get $~lib/rt/itcms/pinSpace + i32.const 3 + call $~lib/rt/itcms/Object#linkTo + end + local.get $ptr + return + ) + (func $~lib/rt/itcms/__unpin (param $ptr i32) + (local $obj i32) + local.get $ptr + i32.eqz + if + return + end + local.get $ptr + i32.const 20 + i32.sub + local.set $obj + local.get $obj + call $~lib/rt/itcms/Object#get:color + i32.const 3 + i32.ne + if + i32.const 19984 + i32.const 352 + i32.const 352 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/state + i32.const 1 + i32.eq + if + local.get $obj + call $~lib/rt/itcms/Object#makeGray + else + local.get $obj + call $~lib/rt/itcms/Object#unlink + local.get $obj + global.get $~lib/rt/itcms/fromSpace + global.get $~lib/rt/itcms/white + call $~lib/rt/itcms/Object#linkTo + end + ) + (func $~lib/rt/itcms/__collect + i32.const 0 + drop + global.get $~lib/rt/itcms/state + i32.const 0 + i32.gt_s + if + loop $while-continue|0 + global.get $~lib/rt/itcms/state + i32.const 0 + i32.ne + if + call $~lib/rt/itcms/step + drop + br $while-continue|0 + end + end + end + call $~lib/rt/itcms/step + drop + loop $while-continue|1 + global.get $~lib/rt/itcms/state + i32.const 0 + i32.ne + if + call $~lib/rt/itcms/step + drop + br $while-continue|1 + end + end + global.get $~lib/rt/itcms/total + i64.extend_i32_u + i32.const 200 + i64.extend_i32_u + i64.mul + i64.const 100 + i64.div_u + i32.wrap_i64 + i32.const 1024 + i32.add + global.set $~lib/rt/itcms/threshold + i32.const 0 + drop + i32.const 0 + drop + ) + (func $assembly/gas/GasCounterU64#get:gas (param $this i32) (result i64) + local.get $this + i64.load + ) + (func $assembly/gas/GasCounter#set@override (param $0 i32) (param $1 i64) + (local $2 i32) + block $default + block $case0 + local.get $0 + i32.const 8 + i32.sub + i32.load + local.set $2 + local.get $2 + i32.const 51 + i32.eq + br_if $case0 + br $default + end + local.get $0 + local.get $1 + call $assembly/gas/GasCounterU64#set + return + end + unreachable + ) + (func $assembly/gas/GasCounter#sub@override (param $0 i32) (param $1 i64) (result i32) + (local $2 i32) + block $default + block $case0 + local.get $0 + i32.const 8 + i32.sub + i32.load + local.set $2 + local.get $2 + i32.const 51 + i32.eq + br_if $case0 + br $default + end + local.get $0 + local.get $1 + call $assembly/gas/GasCounterU64#sub + return + end + unreachable + ) + (func $assembly/gas/GasCounter#get@override (param $0 i32) (result i64) + (local $1 i32) + block $default + block $case0 + local.get $0 + i32.const 8 + i32.sub + i32.load + local.set $1 + local.get $1 + i32.const 51 + i32.eq + br_if $case0 + br $default + end + local.get $0 + call $assembly/gas/GasCounterU64#get + return + end + unreachable + ) + (func $~lib/rt/__visit_globals (param $0 i32) + (local $1 i32) + i32.const 480 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 8176 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 13120 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 16800 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 9376 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 288 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 19920 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 19984 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 15232 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 16288 + local.get $0 + call $~lib/rt/itcms/__visit + global.get $assembly/api/interpreter + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/RELEVANT_ARGS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/REQUIRED_BYTES + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/DECODERS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/INSTRUCTIONS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_PAGE + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/codec/MASKS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions-exe/RUN + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + ) + (func $~lib/arraybuffer/ArrayBufferView~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/object/Object~visit (param $0 i32) (param $1 i32) + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/typedarray/Uint8Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/memory-page/Page~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory-page/RawPage~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/Memory~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory-page/Arena~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $"~lib/map/Map~visit" (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $"~lib/map/Map#__visit" + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit + ) + (func $assembly/memory/Result~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/ChunkBytes~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/Chunks~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/PageData~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/function/Function<%28u8%29=>u8>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28u8%29=>u8>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28u8%29=>u8>#__visit + ) + (func $assembly/interpreter/Interpreter~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/Program~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/Mask~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/JumpTable~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/BasicBlocks~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/CodeAndMetadata~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/codec/Decoder~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + i32.const 1 + drop + local.get $this + local.set $cur + local.get $cur + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray<~lib/string/String>#__visit + ) + (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/api-generic/VmOutput~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/api-generic/InitialChunk~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/api-generic/VmInput~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=16 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=20 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=24 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/memory/MemoryBuilder~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array<~lib/string/String>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<~lib/string/String>#__visit + ) + (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit + ) + (func $assembly/program/ResolvedArguments~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=32 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/dataview/DataView~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/rt/__visit_members (param $0 i32) (param $1 i32) + block $invalid + block $~lib/dataview/DataView + block $~lib/staticarray/StaticArray + block $~lib/array/Array + block $assembly/interpreter/BranchResult + block $assembly/interpreter/DjumpResult + block $assembly/program/ResolvedArguments + block $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> + block $~lib/array/Array<~lib/string/String> + block $assembly/gas/GasCounterU64 + block $assembly/memory/MemoryBuilder + block $~lib/array/Array + block $assembly/api-generic/InitialPage + block $assembly/api-generic/VmInput + block $~lib/array/Array + block $assembly/api-generic/InitialChunk + block $assembly/api-generic/VmOutput + block $~lib/array/Array + block $~lib/array/Array + block $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> + block $assembly/codec/ValOffset + block $~lib/staticarray/StaticArray<~lib/string/String> + block $assembly/codec/Decoder + block $assembly/program/CodeAndMetadata + block $assembly/gas/GasCounter + block $~lib/staticarray/StaticArray + block $assembly/program/BasicBlocks + block $assembly/program/JumpTable + block $~lib/staticarray/StaticArray + block $assembly/program/Mask + block $assembly/program/Program + block $assembly/interpreter/Interpreter + block $~lib/function/Function<%28u8%29=>u8> + block $~lib/array/Array + block $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> + block $assembly/memory/PageData + block $assembly/memory/Chunks + block $~lib/staticarray/StaticArray + block $assembly/memory/ChunkBytes + block $assembly/memory/Result + block $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> + block $assembly/instructions/outcome/OutcomeData + block $"~lib/map/Map" + block $~lib/array/Array + block $assembly/memory-page/Arena + block $assembly/memory/Memory + block $~lib/staticarray/StaticArray + block $assembly/memory-page/RawPage + block $assembly/memory-page/Page + block $assembly/memory/MaybePageFault + block $~lib/array/Array + block $assembly/arguments/Nibbles + block $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> + block $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> + block $assembly/arguments/Args + block $~lib/typedarray/Uint8Array + block $~lib/array/Array + block $~lib/arraybuffer/ArrayBufferView + block $~lib/string/String + block $~lib/arraybuffer/ArrayBuffer + block $~lib/object/Object + local.get $0 + i32.const 8 + i32.sub + i32.load + br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $~lib/arraybuffer/ArrayBufferView $~lib/array/Array $~lib/typedarray/Uint8Array $assembly/arguments/Args $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $assembly/arguments/Nibbles $~lib/array/Array $assembly/memory/MaybePageFault $assembly/memory-page/Page $assembly/memory-page/RawPage $~lib/staticarray/StaticArray $assembly/memory/Memory $assembly/memory-page/Arena $~lib/array/Array $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $assembly/memory/Result $assembly/memory/ChunkBytes $~lib/staticarray/StaticArray $assembly/memory/Chunks $assembly/memory/PageData $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $~lib/array/Array $~lib/function/Function<%28u8%29=>u8> $assembly/interpreter/Interpreter $assembly/program/Program $assembly/program/Mask $~lib/staticarray/StaticArray $assembly/program/JumpTable $assembly/program/BasicBlocks $~lib/staticarray/StaticArray $assembly/gas/GasCounter $assembly/program/CodeAndMetadata $assembly/codec/Decoder $~lib/staticarray/StaticArray<~lib/string/String> $assembly/codec/ValOffset $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> $~lib/array/Array $~lib/array/Array $assembly/api-generic/VmOutput $assembly/api-generic/InitialChunk $~lib/array/Array $assembly/api-generic/VmInput $assembly/api-generic/InitialPage $~lib/array/Array $assembly/memory/MemoryBuilder $assembly/gas/GasCounterU64 $~lib/array/Array<~lib/string/String> $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> $assembly/program/ResolvedArguments $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $~lib/array/Array $~lib/staticarray/StaticArray $~lib/dataview/DataView $invalid + end + return + end + return + end + return + end + local.get $0 + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/typedarray/Uint8Array~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/Page~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/RawPage~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory/Memory~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/Arena~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $"~lib/map/Map~visit" + return + end + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/Result~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/ChunkBytes~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory/Chunks~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/PageData~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28u8%29=>u8>~visit + return + end + local.get $0 + local.get $1 + call $assembly/interpreter/Interpreter~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/Program~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/Mask~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/program/JumpTable~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/BasicBlocks~visit + return + end + return + end + return + end + local.get $0 + local.get $1 + call $assembly/program/CodeAndMetadata~visit + return + end + local.get $0 + local.get $1 + call $assembly/codec/Decoder~visit + return + end + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray<~lib/string/String>~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/api-generic/VmOutput~visit + return + end + local.get $0 + local.get $1 + call $assembly/api-generic/InitialChunk~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/api-generic/VmInput~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/MemoryBuilder~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<~lib/string/String>~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/ResolvedArguments~visit + return + end + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/dataview/DataView~visit + return + end + unreachable + ) + (func $~setArgumentsLength (param $0 i32) + local.get $0 + global.set $~argumentsLength + ) + (func $~start + call $start:assembly/index + ) + (func $~stack_check + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__data_end + i32.lt_s + if + i32.const 53072 + i32.const 53120 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + ) + (func $assembly/arguments/Args#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 6 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:b + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:c + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:d + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/arguments/Args.from (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32) + (local $x i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $x + i32.store + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $a + call $assembly/arguments/Args#set:a + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $b + call $assembly/arguments/Args#set:b + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $c + call $assembly/arguments/Args#set:c + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $d + call $assembly/arguments/Args#set:d + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/typedarray/Uint8Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/typedarray/Uint8Array#subarray (param $this i32) (param $begin i32) (param $end i32) (result i32) + (local $array i32) + (local $begin|4 i32) + (local $end|5 i32) + (local $len i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + (local $out i32) + (local $buf i32) + (local $19 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + block $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $array + i32.store + local.get $begin + local.set $begin|4 + local.get $end + local.set $end|5 + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + local.get $begin|4 + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $begin|4 + i32.add + local.tee $7 + i32.const 0 + local.tee $8 + local.get $7 + local.get $8 + i32.gt_s + select + else + local.get $begin|4 + local.tee $9 + local.get $len + local.tee $10 + local.get $9 + local.get $10 + i32.lt_s + select + end + local.set $begin|4 + local.get $end|5 + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $end|5 + i32.add + local.tee $11 + i32.const 0 + local.tee $12 + local.get $11 + local.get $12 + i32.gt_s + select + else + local.get $end|5 + local.tee $13 + local.get $len + local.tee $14 + local.get $13 + local.get $14 + i32.lt_s + select + end + local.set $end|5 + local.get $end|5 + local.tee $15 + local.get $begin|4 + local.tee $16 + local.get $15 + local.get $16 + i32.gt_s + select + local.set $end|5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=8 + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $buf + local.get $out + local.get $buf + i32.store + local.get $out + local.get $buf + i32.const 0 + call $~lib/rt/itcms/__link + local.get $out + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $begin|4 + i32.const 0 + i32.shl + i32.add + i32.store offset=4 + local.get $out + local.get $end|5 + local.get $begin|4 + i32.sub + i32.const 0 + i32.shl + i32.store offset=8 + local.get $out + br $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" + end + local.set $19 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $19 + return + ) + (func $~lib/typedarray/Uint8Array#__get (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + i32.ge_u + if + i32.const 480 + i32.const 720 + i32.const 167 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $index + i32.add + i32.load8_u + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/arguments/decodeI32 (param $input i32) (param $start i32) (param $end i32) (result i32) + (local $data i32) + (local $value1 f64) + (local $value2 f64) + (local $len i32) + (local $num i32) + (local $i i32) + (local $msb i32) + (local $prefix i32) + (local $i|11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $input + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $start + local.get $end + local.get $start + i32.gt_u + if (result i32) + local.get $end + else + local.get $start + end + call $~lib/typedarray/Uint8Array#subarray + local.tee $data + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.0 (result f64) + f64.const 4 + local.set $value1 + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.0 + end + i32.trunc_sat_f64_u + local.set $len + i32.const 0 + local.set $num + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_u + if + local.get $num + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.get $i + i32.const 8 + i32.mul + i32.shl + i32.or + local.set $num + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $len + i32.const 0 + i32.gt_u + if (result i32) + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $len + i32.const 1 + i32.sub + call $~lib/typedarray/Uint8Array#__get + i32.const 128 + i32.and + else + i32.const 0 + end + local.set $msb + local.get $msb + i32.const 0 + i32.gt_u + if (result i32) + i32.const 255 + else + i32.const 0 + end + local.set $prefix + local.get $len + local.set $i|11 + loop $for-loop|1 + local.get $i|11 + i32.const 4 + i32.lt_u + if + local.get $num + local.get $prefix + local.get $i|11 + i32.const 8 + i32.mul + i32.shl + i32.or + local.set $num + local.get $i|11 + i32.const 1 + i32.add + local.set $i|11 + br $for-loop|1 + end + end + local.get $num + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $start:assembly/arguments~anonymous|1 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/arguments/Nibbles#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 2 + i32.const 9 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Nibbles#set:low + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Nibbles#set:hig + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/arguments/nibbles (param $byte i32) (result i32) + (local $low i32) + (local $hig i32) + (local $n i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $byte + i32.const 15 + i32.and + local.set $low + local.get $byte + i32.const 255 + i32.and + i32.const 4 + i32.const 7 + i32.and + i32.shr_u + local.set $hig + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Nibbles#constructor + local.tee $n + i32.store + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $low + call $assembly/arguments/Nibbles#set:low + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $hig + call $assembly/arguments/Nibbles#set:hig + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/arguments/twoImm (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $first i32) + (local $second i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.1 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.1 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $first + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $second + local.get $first + local.get $second + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|2 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $lim + call $assembly/arguments/twoImm + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $start:assembly/arguments~anonymous|3 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/arguments~anonymous|4 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/typedarray/Uint8Array#subarray@varargs (param $this i32) (param $begin i32) (param $end i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $begin + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $begin + local.get $end + call $~lib/typedarray/Uint8Array#subarray + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/arguments/decodeU32 (param $data i32) (result i32) + (local $num i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 2 + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 3 + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + local.set $num + local.get $num + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/arguments~anonymous|5 (param $data i32) (param $_lim i32) (result i32) + (local $a i32) + (local $b i32) + (local $c i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Nibbles#get:low + local.set $a + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/decodeU32 + local.set $b + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 5 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/decodeU32 + local.set $c + local.get $a + i32.const 255 + i32.and + local.get $b + local.get $c + i32.const 0 + call $assembly/arguments/Args.from + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/arguments~anonymous|6 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $immA i32) + (local $immB i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.2 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.2 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $immA + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $immB + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $immA + local.get $immB + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|7 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $immA i32) + (local $offs i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.3 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.3 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $immA + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $offs + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $immA + local.get $offs + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|8 (param $data i32) (param $_lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|9 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|10 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|11 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + i32.const 1 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $lim + i32.const 1 + i32.gt_u + if (result i32) + local.get $lim + i32.const 1 + i32.sub + else + i32.const 0 + end + call $assembly/arguments/twoImm + local.tee $result + i32.store offset=12 + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:a + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/arguments/Args.from + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/arguments~anonymous|12 (param $data i32) (param $_lim i32) (result i32) + (local $a i32) + (local $b i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $a + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $b + i32.store offset=8 + local.get $a + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $a + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $b + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + i32.const 0 + call $assembly/arguments/Args.from + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/array/ensureCapacity (param $array i32) (param $newSize i32) (param $alignLog2 i32) (param $canGrow i32) + (local $oldCapacity i32) + (local $oldData i32) + (local $6 i32) + (local $7 i32) + (local $newCapacity i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $newData i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $array + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + local.set $oldCapacity + local.get $newSize + local.get $oldCapacity + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + local.get $newSize + i32.const 1073741820 + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8128 + i32.const 19 + i32.const 48 + call $~lib/builtins/abort + unreachable + end + local.get $array + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $oldData + local.get $newSize + local.tee $6 + i32.const 8 + local.tee $7 + local.get $6 + local.get $7 + i32.gt_u + select + local.get $alignLog2 + i32.shl + local.set $newCapacity + local.get $canGrow + if + local.get $oldCapacity + i32.const 1 + i32.shl + local.tee $9 + i32.const 1073741820 + local.tee $10 + local.get $9 + local.get $10 + i32.lt_u + select + local.tee $11 + local.get $newCapacity + local.tee $12 + local.get $11 + local.get $12 + i32.gt_u + select + local.set $newCapacity + end + local.get $oldData + local.get $newCapacity + call $~lib/rt/itcms/__renew + local.set $newData + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $newData + local.get $oldData + i32.ne + if + local.get $array + local.get $newData + i32.store + local.get $array + local.get $newData + i32.store offset=4 + local.get $array + local.get $newData + i32.const 0 + call $~lib/rt/itcms/__link + end + local.get $array + local.get $newCapacity + i32.store offset=8 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 1296 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/MISSING_INSTRUCTION + i32.const 1344 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/SBRK + global.get $~lib/memory/__stack_pointer + i32.const 231 + i32.const 2 + i32.const 10 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.const 1376 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 1408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 5 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 6 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 7 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 8 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 9 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 10 + i32.const 1456 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 11 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 12 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 13 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 14 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 15 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 16 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 17 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 18 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 19 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 20 + i32.const 1488 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneExtImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 21 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 22 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 23 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 24 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 25 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 26 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 27 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 28 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 29 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 30 + i32.const 1536 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 31 + i32.const 1584 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 32 + i32.const 1632 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 33 + i32.const 1680 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 34 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 35 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 36 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 37 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 38 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 39 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 40 + i32.const 1728 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 41 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 42 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 43 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 44 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 45 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 46 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 47 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 48 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 49 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 50 + i32.const 1760 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 51 + i32.const 1808 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 52 + i32.const 1856 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 53 + i32.const 1904 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 54 + i32.const 1952 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 55 + i32.const 2000 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 56 + i32.const 2048 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 57 + i32.const 2096 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 58 + i32.const 2144 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 59 + i32.const 2192 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 60 + i32.const 2240 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 61 + i32.const 2288 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 62 + i32.const 2336 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 63 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 64 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 65 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 66 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 67 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 68 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 69 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 70 + i32.const 2384 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 71 + i32.const 2448 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 72 + i32.const 2512 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 73 + i32.const 2576 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 74 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 75 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 76 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 77 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 78 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 79 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 80 + i32.const 2640 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 81 + i32.const 2688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 82 + i32.const 2736 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 83 + i32.const 2784 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 84 + i32.const 2848 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 85 + i32.const 2912 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 86 + i32.const 2976 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 87 + i32.const 3040 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 88 + i32.const 3104 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 89 + i32.const 3168 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 90 + i32.const 3232 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 91 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 92 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 93 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 94 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 95 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 96 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 97 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 98 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 99 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 100 + i32.const 3296 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 101 + global.get $assembly/instructions/SBRK + call $~lib/array/Array#__set + local.get $0 + i32.const 102 + i32.const 3344 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 103 + i32.const 3408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 104 + i32.const 3472 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 105 + i32.const 3536 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 106 + i32.const 3600 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 107 + i32.const 3664 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 108 + i32.const 3728 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 109 + i32.const 3776 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 110 + i32.const 3824 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 111 + i32.const 3872 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 112 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 113 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 114 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 115 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 116 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 117 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 118 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 119 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 120 + i32.const 3920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 121 + i32.const 3968 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 122 + i32.const 4016 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 123 + i32.const 4064 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 124 + i32.const 4112 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 125 + i32.const 4160 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 126 + i32.const 4208 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 127 + i32.const 4256 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 128 + i32.const 4304 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 129 + i32.const 4352 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 130 + i32.const 4400 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 131 + i32.const 4448 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 132 + i32.const 4496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 133 + i32.const 4544 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 134 + i32.const 4592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 135 + i32.const 4624 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 136 + i32.const 4672 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 137 + i32.const 4720 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 138 + i32.const 4768 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 139 + i32.const 4816 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 140 + i32.const 4864 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 141 + i32.const 4912 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 142 + i32.const 4960 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 143 + i32.const 5008 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 144 + i32.const 5056 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 145 + i32.const 5120 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 146 + i32.const 5184 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 147 + i32.const 5248 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 148 + i32.const 5296 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 149 + i32.const 5344 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 150 + i32.const 5392 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 151 + i32.const 5440 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 152 + i32.const 5488 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 153 + i32.const 5536 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 154 + i32.const 5584 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 155 + i32.const 5632 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 156 + i32.const 5696 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 157 + i32.const 5760 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 158 + i32.const 5824 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 159 + i32.const 5872 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 160 + i32.const 5936 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 161 + i32.const 5984 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 162 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 163 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 164 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 165 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 166 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 167 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 168 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 169 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 170 + i32.const 6048 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 171 + i32.const 6096 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 172 + i32.const 6144 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 173 + i32.const 6192 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 174 + i32.const 6240 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 175 + i32.const 6288 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 176 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 177 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 178 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 179 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 180 + i32.const 6336 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegTwoImm + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 181 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 182 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 183 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 184 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 185 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 186 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 187 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 188 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 189 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 190 + i32.const 6400 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 191 + i32.const 6432 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 192 + i32.const 6464 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 193 + i32.const 6496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 194 + i32.const 6544 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 195 + i32.const 6592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 196 + i32.const 6640 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 197 + i32.const 6688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 198 + i32.const 6736 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 199 + i32.const 6784 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 200 + i32.const 6832 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 201 + i32.const 6864 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 202 + i32.const 6896 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 203 + i32.const 6928 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 204 + i32.const 6976 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 205 + i32.const 7024 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 206 + i32.const 7072 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 207 + i32.const 7120 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 208 + i32.const 7168 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 209 + i32.const 7216 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 210 + i32.const 7264 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 211 + i32.const 7296 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 212 + i32.const 7328 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 213 + i32.const 7360 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 214 + i32.const 7408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 215 + i32.const 7456 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 216 + i32.const 7504 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 217 + i32.const 7552 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 218 + i32.const 7600 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 219 + i32.const 7648 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 220 + i32.const 7696 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 221 + i32.const 7744 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 222 + i32.const 7792 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 223 + i32.const 7840 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 224 + i32.const 7888 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 225 + i32.const 7936 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 226 + i32.const 7968 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 227 + i32.const 8000 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 228 + i32.const 8032 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 229 + i32.const 8064 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 230 + i32.const 8096 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/INSTRUCTIONS + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/MaybePageFault#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 11 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:isFault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:isAccess + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:fault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/arraybuffer/ArrayBufferView#constructor (param $this i32) (param $length i32) (param $alignLog2 i32) (result i32) + (local $buffer i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 3 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:buffer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:byteLength + local.get $length + i32.const 1073741820 + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8224 + i32.const 19 + i32.const 57 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $length + local.get $alignLog2 + i32.shl + local.tee $length + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $buffer + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $~lib/arraybuffer/ArrayBufferView#set:buffer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $buffer + call $~lib/arraybuffer/ArrayBufferView#set:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $length + call $~lib/arraybuffer/ArrayBufferView#set:byteLength + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $length + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#constructor + local.tee $this + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/memory-page/Page#constructor (param $this i32) (param $access i32) (param $raw i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 12 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $access + call $assembly/memory-page/Page#set:access + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $raw + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory-page/Page#set:raw + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory-page/RawPage#constructor (param $this i32) (param $id i32) (param $page i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 13 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $id + call $assembly/memory-page/RawPage#set:id + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $page + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory-page/RawPage#set:page + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $start:assembly/memory + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + call $start:assembly/memory-page + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + global.set $assembly/memory/NO_PAGE_FAULT + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + global.set $assembly/memory/EMPTY_UINT8ARRAY + i32.const 0 + global.get $assembly/memory-page/Access.None + i32.const 0 + i32.const -1 + i32.const 0 + call $assembly/memory-page/RawPage#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/memory-page/Page#constructor + global.set $assembly/memory/EMPTY_PAGE + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i64) + (local $value i64) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/OutcomeData#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.const 19 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/instructions/outcome/Outcome.Ok + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:staticJump + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:dJump + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/instructions/outcome/Result.PANIC + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:exitCode + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/bit~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.popcnt + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.popcnt + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.clz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.clz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ctz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.ctz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u8SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u16SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|8 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.const 65535 + i32.and + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|9 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/polyfills/bswap + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/instructions/outcome/staticJump (param $offset i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.StaticJump + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $offset + call $assembly/instructions/outcome/OutcomeData#set:staticJump + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/branch~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.eq + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.ne + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.lt_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.le_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.ge_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.gt_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.lt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.le_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.ge_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.gt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.eq + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ne + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_u + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ge_u + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ge_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/jump~anonymous|0 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:a + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/instructions/outcome/dJump (param $address i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.DynamicJump + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $address + call $assembly/instructions/outcome/OutcomeData#set:dJump + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/jump~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $address i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + local.get $address + call $assembly/instructions/outcome/dJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/jump~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/jump~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $address i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:d + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + local.get $address + call $assembly/instructions/outcome/dJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.const 32 + i64.shl + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/load~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory/Chunks#constructor (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 24 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:fault + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:first + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:second + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory/Chunks#constructor@varargs (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $first + i32.store + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $second + i32.store offset=4 + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + local.get $first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + local.get $second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + local.get $4 + call $assembly/memory/Chunks#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $"~lib/map/Map#find" (param $this i32) (param $key i32) (param $hashCode i32) (result i32) + (local $entry i32) + (local $taggedNext i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + i32.load + local.set $entry + loop $while-continue|0 + local.get $entry + if + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + local.set $taggedNext + local.get $taggedNext + i32.const 1 + i32.and + i32.eqz + if (result i32) + local.get $entry + call $"~lib/map/MapEntry#get:key" + local.get $key + i32.eq + else + i32.const 0 + end + if + local.get $entry + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $taggedNext + i32.const 1 + i32.const -1 + i32.xor + i32.and + local.set $entry + br $while-continue|0 + end + end + i32.const 0 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $"~lib/map/Map#has" (param $this i32) (param $key i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $key + local.get $key + call $~lib/util/hash/HASH + call $"~lib/map/Map#find" + i32.const 0 + i32.ne + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/PageData#constructor (param $this i32) (param $fault i32) (param $page i32) (param $relativeAddress i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 25 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/PageData#set:fault + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $page + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/PageData#set:page + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $relativeAddress + call $assembly/memory/PageData#set:relativeAddress + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory/fault (param $address i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isFault + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $address + call $assembly/memory/MaybePageFault#set:fault + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $"~lib/map/Map#get" (param $this i32) (param $key i32) (result i32) + (local $entry i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $key + local.get $key + call $~lib/util/hash/HASH + call $"~lib/map/Map#find" + local.set $entry + local.get $entry + i32.eqz + if + i32.const 9376 + i32.const 9440 + i32.const 105 + i32.const 17 + call $~lib/builtins/abort + unreachable + end + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory-page/Page#can (param $this i32) (param $access i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/Page#get:access + global.get $assembly/memory-page/Access.Write + i32.eq + if (result i32) + i32.const 1 + else + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/Page#get:access + local.get $access + i32.eq + end + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/Memory#getPage (param $this i32) (param $access i32) (param $address i32) (result i32) + (local $pageIdx i32) + (local $relAddress i32) + (local $pageStart i32) + (local $page i32) + (local $f i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $address + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $pageIdx + local.get $address + global.get $assembly/memory-page/PAGE_SIZE + i32.rem_u + local.set $relAddress + local.get $pageIdx + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + local.set $pageStart + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/memory/Memory#get:pages + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $pageIdx + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.get $pageStart + call $assembly/memory/fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory/EMPTY_PAGE + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/memory/Memory#get:pages + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $pageIdx + call $"~lib/map/Map#get" + local.tee $page + i32.store offset=8 + local.get $page + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $access + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $pageStart + call $assembly/memory/fault + local.tee $f + i32.store offset=12 + local.get $f + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isAccess + i32.const 0 + local.get $f + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory/EMPTY_PAGE + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $page + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/typedarray/Uint8Array#fill (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $value + local.get $start + local.get $end + call $~lib/util/bytes/FILL + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/typedarray/Uint8Array#fill@varargs (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $start + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $value + local.get $start + local.get $end + call $~lib/typedarray/Uint8Array#fill + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory-page/RawPage#get:data (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:page + i32.const 0 + i32.eq + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory-page/RawPage#set:page + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:page + local.tee $1 + i32.store offset=12 + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 9616 + i32.const 42 + i32.const 12 + call $~lib/builtins/abort + unreachable + end + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/Memory#getChunks (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) + (local $pageData i32) + (local $page i32) + (local $relativeAddress i32) + (local $endAddress i32) + (local $needSecondPage i32) + (local $first i32) + (local $secondPageIdx i32) + (local $secondPageStart i32) + (local $secondPage i32) + (local $f i32) + (local $firstChunk i32) + (local $secondChunk i32) + (local $16 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + local.get $bytes + i32.const 255 + i32.and + i32.const 0 + i32.eq + if + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $access + local.get $address + call $assembly/memory/Memory#getPage + local.tee $pageData + i32.store offset=4 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/PageData#get:fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/MaybePageFault#get:isFault + if + i32.const 0 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/PageData#get:fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/PageData#get:page + local.tee $page + i32.store offset=12 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/PageData#get:relativeAddress + local.set $relativeAddress + local.get $relativeAddress + local.get $bytes + i32.const 255 + i32.and + i32.add + local.set $endAddress + local.get $endAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.gt_u + local.set $needSecondPage + local.get $needSecondPage + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $page + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $relativeAddress + local.get $endAddress + call $~lib/typedarray/Uint8Array#subarray + local.tee $first + i32.store offset=20 + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $first + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + i32.const 2 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + local.get $address + local.get $bytes + i32.const 255 + i32.and + i32.add + i64.extend_i32_u + global.get $assembly/memory/MEMORY_SIZE + i64.rem_s + i32.wrap_i64 + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $secondPageIdx + local.get $secondPageIdx + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + local.set $secondPageStart + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/Memory#get:pages + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $secondPageIdx + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.get $secondPageStart + call $assembly/memory/fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/Memory#get:pages + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $secondPageIdx + call $"~lib/map/Map#get" + local.tee $secondPage + i32.store offset=24 + local.get $secondPage + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $access + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $secondPageStart + call $assembly/memory/fault + local.tee $f + i32.store offset=28 + local.get $f + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isAccess + i32.const 0 + local.get $f + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $page + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $relativeAddress + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $firstChunk + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $secondPage + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + local.get $relativeAddress + local.get $bytes + i32.const 255 + i32.and + i32.add + global.get $assembly/memory-page/PAGE_SIZE + i32.sub + call $~lib/typedarray/Uint8Array#subarray + local.tee $secondChunk + i32.store offset=36 + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $firstChunk + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + local.get $secondChunk + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory/Chunks#constructor + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + ) + (func $assembly/memory/ChunkBytes#constructor (param $this i32) (param $fault i32) (param $bytes i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 22 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $fault + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory/ChunkBytes#set:fault + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $bytes + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory/ChunkBytes#set:bytes + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory/ChunkBytes#constructor@varargs (param $this i32) (param $fault i32) (param $bytes i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/staticarray/StaticArray#constructor + local.tee $bytes + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $fault + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $bytes + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/memory/ChunkBytes#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/getBytes (param $bytes i32) (param $first i32) (param $second i32) (result i32) + (local $res i32) + (local $len i32) + (local $i i32) + (local $i|6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $bytes + i32.const 255 + i32.and + call $~lib/staticarray/StaticArray#constructor + local.tee $res + i32.store + local.get $first + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $i + local.get $first + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|6 + loop $for-loop|1 + local.get $i|6 + local.get $second + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $len + local.get $i|6 + i32.add + local.get $second + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + local.get $i|6 + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $i|6 + i32.const 1 + i32.add + local.set $i|6 + br $for-loop|1 + end + end + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $assembly/memory/Memory#getBytes (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) + (local $res i32) + (local $data i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $access + local.get $address + local.get $bytes + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $assembly/memory/MaybePageFault#get:isFault + if + i32.const 0 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/ChunkBytes#constructor@varargs + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + global.get $~lib/memory/__stack_pointer + local.get $bytes + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:first + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:second + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/getBytes + local.tee $data + i32.store offset=16 + i32.const 0 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/ChunkBytes#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/memory/Result#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 21 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/memory/Result#set:ok + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/Result#set:fault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory/Memory#getU8 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/instructions/outcome/okOrFault (param $pageFault i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MaybePageFault#get:isAccess + if (result i32) + global.get $assembly/instructions/outcome/Result.FAULT_ACCESS + else + global.get $assembly/instructions/outcome/Result.FAULT + end + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MaybePageFault#get:fault + call $assembly/instructions/outcome/OutcomeData#set:exitCode + end + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/load~anonymous|2 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getI8 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/u8SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|3 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU16 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getI16 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $l i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/Result#set:fault + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.const 15 + i32.and + i32.shl + i32.or + local.set $l + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $l + call $assembly/instructions/utils/u16SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU32 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getI32 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $l i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/Result#set:fault + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i32.or + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i32.or + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i32.or + local.set $l + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $l + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU64 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 8 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 8 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 16 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 24 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 4 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 32 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 5 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 40 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 6 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 48 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 7 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 56 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU64 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU64 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/logic~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.xor + i64.const -1 + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $c i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $c + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $c + i64.add + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.mul + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.const 4294967296 + i64.or + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i32.add + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 2 + i64.const 32 + call $~lib/math/ipow64 + i64.add + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + i64.sub + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.mul + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i32.div_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i32.MIN_VALUE + i64.extend_i32_s + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i32.rem_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i32) + (local $a i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i32.const -1 + i32.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i32.MIN_VALUE + i32.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + i64.extend_i32_s + local.get $a + i64.extend_i32_s + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.div_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i64.MIN_VALUE + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|18 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.rem_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|19 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i64.MIN_VALUE + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|20 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperSigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|21 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperUnsigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|22 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperSignedUnsigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|23 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.lt_s + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|24 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.lt_u + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|25 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.gt_s + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|26 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.gt_u + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/mov~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_l + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_l_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/set~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.lt_u + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.lt_s + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.gt_u + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.gt_s + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_u + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/set~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_s + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/shift~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $imm i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $imm + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $imm + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $regValue i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $regValue + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regValue + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/typedarray/Uint8Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + i32.ge_u + if + i32.const 480 + i32.const 720 + i32.const 178 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $index + i32.add + local.get $value + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU8 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 1 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|0 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU16 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 2 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.gt_s + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $value + i32.const 65535 + i32.and + i32.const 8 + i32.const 15 + i32.and + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + else + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 65535 + i32.and + i32.const 8 + i32.const 15 + i32.and + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|1 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU32 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $v i32) + (local $len i32) + (local $i i32) + (local $i|7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 4 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $value + local.set $v + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + local.get $v + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i32.const 8 + i32.shr_u + local.set $v + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i|7 + local.get $v + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i32.const 8 + i32.shr_u + local.set $v + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/instructions/store~anonymous|2 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#setU32 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU64 (param $this i32) (param $address i32) (param $value i64) (result i32) + (local $res i32) + (local $v i64) + (local $len i32) + (local $i i32) + (local $i|7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 8 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $value + local.set $v + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + local.get $v + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i64.const 8 + i64.shr_u + local.set $v + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i|7 + local.get $v + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i64.const 8 + i64.shr_u + local.set $v + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/instructions/store~anonymous|3 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Memory#setU64 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/memory/Memory#setU32 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Memory#setU64 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/instructions/outcome/status (param $result i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $result + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Result.HOST + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $id + call $assembly/instructions/outcome/OutcomeData#set:exitCode + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:a + call $assembly/instructions/outcome/hostCall + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#pop (param $this i32) (result i32) + (local $len i32) + (local $val i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + local.set $len + local.get $len + i32.const 1 + i32.lt_s + if + i32.const 13120 + i32.const 8128 + i32.const 271 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $len + i32.const 1 + i32.sub + local.tee $len + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $val + i32.store offset=4 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $len + call $~lib/array/Array#set:length_ + local.get $val + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/console/console.log (param $message i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $message + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/bindings/dom/console.log + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory-page/Arena#acquire (param $this i32) (result i32) + (local $allocatedMemory i32) + (local $data i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:free + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + i32.const 0 + i32.gt_s + if + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:free + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#pop + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.set $allocatedMemory + local.get $allocatedMemory + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/Arena#get:arenaBytes + i32.eq + if + i32.const 13168 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/console/console.log + end + global.get $~lib/memory/__stack_pointer + local.get $allocatedMemory + global.get $assembly/memory-page/ALLOCATE_EAGERLY + i32.lt_u + if (result i32) + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + else + i32.const 0 + end + local.tee $data + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + i32.const 1 + i32.add + call $assembly/memory-page/Arena#set:extraPageIndex + i32.const 0 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/RawPage#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) + (local $newBucketsCapacity i32) + (local $newBuckets i32) + (local $newEntriesCapacity i32) + (local $newEntries i32) + (local $oldPtr i32) + (local $oldEnd i32) + (local $newPtr i32) + (local $oldEntry i32) + (local $newEntry i32) + (local $oldEntryKey i32) + (local $newBucketIndex i32) + (local $newBucketPtrBase i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $newBucketsMask + i32.const 1 + i32.add + local.set $newBucketsCapacity + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $newBucketsCapacity + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newBuckets + i32.store + local.get $newBucketsCapacity + i32.const 8 + i32.mul + i32.const 3 + i32.div_s + local.set $newEntriesCapacity + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $newEntriesCapacity + block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.0" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newEntries + i32.store offset=4 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entries" + local.set $oldPtr + local.get $oldPtr + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.1" + end + i32.mul + i32.add + local.set $oldEnd + local.get $newEntries + local.set $newPtr + loop $while-continue|0 + local.get $oldPtr + local.get $oldEnd + i32.ne + if + local.get $oldPtr + local.set $oldEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $newPtr + local.set $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:key" + local.set $oldEntryKey + local.get $newEntry + local.get $oldEntryKey + call $"~lib/map/MapEntry#set:key" + local.get $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:value" + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/MapEntry#set:value" + local.get $oldEntryKey + call $~lib/util/hash/HASH + local.get $newBucketsMask + i32.and + local.set $newBucketIndex + local.get $newBuckets + local.get $newBucketIndex + i32.const 4 + i32.mul + i32.add + local.set $newBucketPtrBase + local.get $newEntry + local.get $newBucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $newBucketPtrBase + local.get $newPtr + i32.store + local.get $newPtr + block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.2" + end + i32.add + local.set $newPtr + end + local.get $oldPtr + block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.3" + end + i32.add + local.set $oldPtr + br $while-continue|0 + end + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBuckets + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBucketsMask + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntries + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntriesCapacity + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#get:entriesCount" + call $"~lib/map/Map#set:entriesOffset" + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) + (local $hashCode i32) + (local $entry i32) + (local $entries i32) + (local $6 i32) + (local $bucketPtrBase i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $key + call $~lib/util/hash/HASH + local.set $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $key + local.get $hashCode + call $"~lib/map/Map#find" + local.set $entry + local.get $entry + if + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.eq + if + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.const 3 + i32.mul + i32.const 4 + i32.div_s + i32.lt_s + if (result i32) + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.const 1 + i32.shl + i32.const 1 + i32.or + end + call $"~lib/map/Map#rehash" + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.tee $entries + i32.store offset=8 + local.get $entries + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.tee $6 + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesOffset" + local.get $6 + block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.4" + end + i32.mul + i32.add + local.set $entry + local.get $entry + local.get $key + call $"~lib/map/MapEntry#set:key" + i32.const 0 + drop + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + local.set $bucketPtrBase + local.get $entry + local.get $bucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $bucketPtrBase + local.get $entry + i32.store + end + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) + (local $freeMemoryStart i32) + (local $newSbrk i64) + (local $pageIdx i32) + (local $i i32) + (local $page i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $freeMemoryStart + i32.store + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $amount + i32.const 0 + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + local.get $amount + i64.extend_i32_u + i64.add + local.set $newSbrk + local.get $newSbrk + global.get $assembly/memory/MEMORY_SIZE + i64.ge_s + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Result#get:fault + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isFault + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $newSbrk + i32.wrap_i64 + call $assembly/memory/Memory#set:sbrkAddress + local.get $newSbrk + i64.const 1 + i64.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i64.extend_i32_s + i64.shr_s + i32.wrap_i64 + local.set $pageIdx + local.get $pageIdx + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.const 1 + i32.add + local.set $i + loop $for-loop|0 + local.get $i + local.get $pageIdx + i32.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:arena + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=12 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory/Memory#get:pages + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $i + i32.const 0 + global.get $assembly/memory-page/Access.Write + local.get $page + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory-page/Page#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $"~lib/map/Map#set" + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $pageIdx + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#sbrk + local.tee $res + i32.store offset=12 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/codec~anonymous|0 (param $firstByte i32) (result i32) + (local $len i32) + (local $i i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $assembly/codec/MASKS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.const 255 + i32.and + i32.lt_u + if + local.get $firstByte + i32.const 255 + i32.and + global.get $assembly/codec/MASKS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $i + call $~lib/array/Array#__get + i32.ge_u + if + i32.const 8 + local.get $i + i32.sub + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/array/Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/array/Array#get:dataStart + local.set $sourceStart + i32.const 0 + i32.eqz + drop + local.get $targetStart + local.get $sourceStart + local.get $sourceLen + i32.const 0 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/liftBytes (param $data i32) (result i32) + (local $p i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $p + i32.store offset=4 + local.get $p + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#set<~lib/array/Array> + local.get $p + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#constructor (param $this i32) (param $source i32) (param $offset i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 38 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $source + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/codec/Decoder#set:source + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $offset + call $assembly/codec/Decoder#set:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/util/string/joinStringArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $4 i32) + (local $estLen i32) + (local $value i32) + (local $i i32) + (local $offset i32) + (local $sepLen i32) + (local $result i32) + (local $i|11 i32) + (local $valueLen i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 14400 + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + end + local.get $lastIndex + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + i32.load + local.tee $4 + i32.store + local.get $4 + if (result i32) + local.get $4 + else + i32.const 14400 + end + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + end + i32.const 0 + local.set $estLen + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $i + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $estLen + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + i32.add + local.set $estLen + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $offset + local.get $separator + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + local.set $sepLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + local.get $sepLen + local.get $lastIndex + i32.mul + i32.add + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=12 + i32.const 0 + local.set $i|11 + loop $for-loop|1 + local.get $i|11 + local.get $lastIndex + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $i|11 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + local.set $valueLen + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value + local.get $valueLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $valueLen + i32.add + local.set $offset + end + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i|11 + i32.const 1 + i32.add + local.set $i|11 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $lastIndex + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + memory.copy + end + local.get $result + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + i32.const 1 + i32.lt_s + drop + i32.const 1 + drop + local.get $this + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/staticarray/StaticArray<~lib/string/String>#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/util/string/joinStringArray + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#ensureBytes (param $this i32) (param $need i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#get:offset + local.get $need + i32.add + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/codec/Decoder#get:source + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $need + i32.const 10 + call $~lib/number/U32#toString + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/codec/Decoder#get:source + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#get:offset + i32.sub + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=12 + i32.const 14560 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $2 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 14560 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 3 + local.get $3 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 14560 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 14400 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 16384 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/ValOffset#constructor (param $this i32) (param $value i32) (param $offset i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 40 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $value + call $assembly/codec/ValOffset#set:value + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $offset + call $assembly/codec/ValOffset#set:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/codec/decodeVarU32 (param $data i32) (result i32) + (local $length i32) + (local $first i32) + (local $3 i32) + (local $4 i32) + (local $msb i32) + (local $number i32) + (local $i i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + i32.const 1 + global.set $~argumentsLength + global.get $assembly/codec/variableLength + i32.load + call_indirect (type $0) + i32.const 255 + i32.and + local.set $length + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $first + local.get $length + i32.const 0 + i32.eq + if + i32.const 0 + local.get $first + i32.const 1 + call $assembly/codec/ValOffset#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.get $length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.const 10 + call $~lib/number/I32#toString + local.tee $4 + i32.store offset=8 + i32.const 16608 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $3 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 16608 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 3 + local.get $4 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 16608 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 14400 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 16384 + i32.const 108 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $first + i32.const 2 + i32.const 8 + local.get $length + i32.sub + call $~lib/math/ipow32 + i32.add + i32.const 2 + i32.const 8 + call $~lib/math/ipow32 + i32.sub + local.get $length + i32.const 8 + i32.mul + i32.shl + local.set $msb + i32.const 0 + local.set $number + local.get $length + i32.const 1 + i32.sub + local.set $i + loop $for-loop|0 + local.get $i + i32.const 0 + i32.ge_s + if + local.get $number + i32.const 8 + i32.shl + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $i + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.add + local.set $number + local.get $i + i32.const 1 + i32.sub + local.set $i + br $for-loop|0 + end + end + local.get $number + local.get $msb + i32.add + local.set $number + i32.const 0 + local.get $number + i32.const 1 + local.get $length + i32.add + call $assembly/codec/ValOffset#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/codec/Decoder#varU32 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/codec/decodeVarU32 + local.tee $v + i32.store offset=12 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/ValOffset#get:offset + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/codec/ValOffset#get:value + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#bytes (param $this i32) (param $len i32) (result i32) + (local $v i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $len + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:source + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $len + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $v + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $len + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/codec/Decoder#remainingBytes (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $v + i32.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/typedarray/Uint8Array#get:length + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/program/CodeAndMetadata#constructor (param $this i32) (param $code i32) (param $metadata i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 37 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $code + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/program/CodeAndMetadata#set:code + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $metadata + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/program/CodeAndMetadata#set:metadata + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/program/extractCodeAndMetadata (param $data i32) (result i32) + (local $decoder i32) + (local $metadataLength i32) + (local $metadata i32) + (local $code i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/codec/Decoder#varU32 + local.set $metadataLength + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $metadataLength + call $assembly/codec/Decoder#bytes + local.tee $metadata + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/codec/Decoder#remainingBytes + local.tee $code + i32.store offset=12 + i32.const 0 + local.get $code + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $metadata + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/program/CodeAndMetadata#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/string/String#concat (param $this i32) (param $other i32) (result i32) + (local $thisSize i32) + (local $otherSize i32) + (local $outSize i32) + (local $out i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $thisSize + local.get $other + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $otherSize + local.get $thisSize + local.get $otherSize + i32.add + local.set $outSize + local.get $outSize + i32.const 0 + i32.eq + if + i32.const 14400 + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $out + local.get $this + local.get $thisSize + memory.copy + local.get $out + local.get $thisSize + i32.add + local.get $other + local.get $otherSize + memory.copy + local.get $out + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $~lib/string/String.__concat (param $left i32) (param $right i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $left + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $right + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/string/String#concat + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/string/String#padStart (param $this i32) (param $length i32) (param $pad i32) (result i32) + (local $thisSize i32) + (local $targetSize i32) + (local $padSize i32) + (local $prependSize i32) + (local $out i32) + (local $repeatCount i32) + (local $restBase i32) + (local $restSize i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $thisSize + local.get $length + i32.const 1 + i32.shl + local.set $targetSize + local.get $pad + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $padSize + local.get $targetSize + local.get $thisSize + i32.lt_u + if (result i32) + i32.const 1 + else + local.get $padSize + i32.eqz + end + if + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $targetSize + local.get $thisSize + i32.sub + local.set $prependSize + global.get $~lib/memory/__stack_pointer + local.get $targetSize + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $prependSize + local.get $padSize + i32.gt_u + if + local.get $prependSize + i32.const 2 + i32.sub + local.get $padSize + i32.div_u + local.set $repeatCount + local.get $repeatCount + local.get $padSize + i32.mul + local.set $restBase + local.get $prependSize + local.get $restBase + i32.sub + local.set $restSize + local.get $out + local.get $pad + local.get $padSize + local.get $repeatCount + call $~lib/memory/memory.repeat + local.get $out + local.get $restBase + i32.add + local.get $pad + local.get $restSize + memory.copy + else + local.get $out + local.get $pad + local.get $prependSize + memory.copy + end + local.get $out + local.get $prependSize + i32.add + local.get $this + local.get $thisSize + memory.copy + local.get $out + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $assembly/index/disassemble~anonymous|0 (param $acc i32) (param $x i32) (param $$2 i32) (param $$3 i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $acc + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $x + i32.const 16 + call $~lib/number/U8#toString + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + i32.const 2 + i32.const 14800 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $~lib/string/String#padStart + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/string/String.__concat + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#reduce<~lib/string/String> (param $this i32) (param $fn i32) (param $initialValue i32) (result i32) + (local $array i32) + (local $fn|4 i32) + (local $initialValue|5 i32) + (local $ptr i32) + (local $i i32) + (local $k i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + block $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" (result i32) + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $array + i32.store + global.get $~lib/memory/__stack_pointer + local.get $fn + local.tee $fn|4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $initialValue + local.tee $initialValue|5 + i32.store offset=8 + local.get $array + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.set $ptr + i32.const 0 + local.set $i + local.get $array + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.set $k + loop $for-loop|0 + local.get $i + local.get $k + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $initialValue|5 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + local.get $ptr + local.get $i + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.get $i + local.get $array + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 4 + global.set $~argumentsLength + local.get $fn|4 + i32.load + call_indirect (type $5) + local.tee $initialValue|5 + i32.store offset=8 + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $initialValue|5 + br $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" + end + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $assembly/codec/Decoder#u8 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/Mask#constructor (param $this i32) (param $packedMask i32) (param $codeLength i32) (result i32) + (local $lastInstructionOffset i32) + (local $i i32) + (local $bits i32) + (local $index i32) + (local $b i32) + (local $isSet i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 31 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + call $assembly/program/Mask#set:bytesToSkip + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + local.get $codeLength + call $~lib/staticarray/StaticArray#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/Mask#set:bytesToSkip + i32.const 0 + local.set $lastInstructionOffset + local.get $packedMask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.sub + local.set $i + loop $for-loop|0 + local.get $i + i32.const 0 + i32.ge_s + if + local.get $packedMask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $bits + local.get $i + i32.const 8 + i32.mul + local.set $index + i32.const 7 + local.set $b + loop $for-loop|2 + local.get $b + i32.const 0 + i32.ge_s + if + local.get $bits + i32.const 128 + i32.and + local.set $isSet + local.get $bits + i32.const 1 + i32.const 7 + i32.and + i32.shl + local.set $bits + local.get $index + local.get $b + i32.add + local.get $codeLength + i32.lt_s + if + local.get $isSet + if (result i32) + i32.const 0 + else + local.get $lastInstructionOffset + i32.const 1 + i32.add + end + local.set $lastInstructionOffset + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/Mask#get:bytesToSkip + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $index + local.get $b + i32.add + local.get $lastInstructionOffset + global.get $assembly/program/MAX_SKIP + i32.const 1 + i32.add + i32.lt_u + if (result i32) + local.get $lastInstructionOffset + else + global.get $assembly/program/MAX_SKIP + i32.const 1 + i32.add + end + call $~lib/staticarray/StaticArray#__set + end + local.get $b + i32.const 1 + i32.sub + local.set $b + br $for-loop|2 + end + end + local.get $i + i32.const 1 + i32.sub + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + ) + (func $assembly/program/JumpTable#constructor (param $this i32) (param $itemBytes i32) (param $data i32) (result i32) + (local $jumps i32) + (local $i i32) + (local $num i64) + (local $j i32) + (local $nextNum i64) + (local $isOverflow i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 33 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + call $assembly/program/JumpTable#set:jumps + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $itemBytes + i32.const 255 + i32.and + i32.const 0 + i32.gt_u + if (result i32) + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.get $itemBytes + i32.const 255 + i32.and + i32.div_s + else + i32.const 0 + end + call $~lib/staticarray/StaticArray#constructor + local.tee $jumps + i32.store offset=8 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + i64.const 0 + local.set $num + local.get $itemBytes + i32.const 1 + i32.sub + i32.const 255 + i32.and + local.set $j + loop $for-loop|1 + local.get $j + i32.const 0 + i32.ge_s + if + local.get $num + i64.const 8 + i64.shl + local.set $nextNum + local.get $nextNum + local.get $num + i64.lt_u + local.set $isOverflow + local.get $nextNum + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + local.get $j + i32.add + call $~lib/typedarray/Uint8Array#__get + i64.extend_i32_u + i64.add + local.set $nextNum + local.get $isOverflow + if (result i32) + i32.const 1 + else + local.get $nextNum + local.get $num + i64.lt_u + end + local.set $isOverflow + local.get $isOverflow + if (result i64) + global.get $~lib/builtins/u64.MAX_VALUE + else + local.get $nextNum + end + local.set $num + local.get $j + i32.const 1 + i32.sub + local.set $j + br $for-loop|1 + end + end + local.get $jumps + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + local.get $itemBytes + i32.const 255 + i32.and + i32.div_s + local.get $num + call $~lib/staticarray/StaticArray#__set + local.get $i + local.get $itemBytes + i32.const 255 + i32.and + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $jumps + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $assembly/program/JumpTable#set:jumps + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/Mask#isInstruction (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + i64.extend_i32_u + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i64.extend_i32_s + i64.ge_u + if + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $index + call $~lib/staticarray/StaticArray#__get + i32.const 0 + i32.eq + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/program/Mask#skipBytesToNextInstruction (param $this i32) (param $i i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $i + i32.const 1 + i32.add + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i32.lt_u + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $i + i32.const 1 + i32.add + call $~lib/staticarray/StaticArray#__get + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/BasicBlocks#constructor (param $this i32) (param $code i32) (param $mask i32) (result i32) + (local $len i32) + (local $isStartOrEnd i32) + (local $n i32) + (local $isInstructionInMask i32) + (local $skipArgs i32) + (local $iData i32) + (local $isTerminating i32) + (local $newBlockStart i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 34 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + call $assembly/program/BasicBlocks#set:isStartOrEnd + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $len + call $~lib/staticarray/StaticArray#constructor + local.tee $isStartOrEnd + i32.store offset=8 + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + i32.const 0 + local.set $n + loop $for-loop|0 + local.get $n + local.get $len + i32.lt_s + if + block $for-continue|0 + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $assembly/program/Mask#isInstruction + local.set $isInstructionInMask + local.get $isInstructionInMask + i32.eqz + if + br $for-continue|0 + end + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipArgs + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#__get + end + local.set $iData + local.get $iData + call $assembly/instructions/Instruction#get:isTerminating + local.set $isTerminating + local.get $isTerminating + if + local.get $n + i32.const 1 + i32.add + local.get $skipArgs + i32.add + local.set $newBlockStart + local.get $newBlockStart + local.get $len + i32.lt_s + if + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $newBlockStart + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + end + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + local.get $n + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.END + i32.or + call $~lib/staticarray/StaticArray#__set + end + end + local.get $n + i32.const 1 + i32.add + local.set $n + br $for-loop|0 + end + end + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + call $assembly/program/BasicBlocks#set:isStartOrEnd + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + ) + (func $assembly/program/Program#constructor (param $this i32) (param $code i32) (param $mask i32) (param $jumpTable i32) (param $basicBlocks i32) (result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 30 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $code + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:code + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:mask + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:jumpTable + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $basicBlocks + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:basicBlocks + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/program/deblob (param $program i32) (result i32) + (local $decoder i32) + (local $jumpTableLength i32) + (local $jumpTableItemLength i32) + (local $codeLength i32) + (local $jumpTableLengthInBytes i32) + (local $rawJumpTable i32) + (local $rawCode i32) + (local $rawMask i32) + (local $mask i32) + (local $jumpTable i32) + (local $basicBlocks i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $program + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#varU32 + local.set $jumpTableLength + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#u8 + local.set $jumpTableItemLength + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#varU32 + local.set $codeLength + local.get $jumpTableLength + local.get $jumpTableItemLength + i32.mul + local.set $jumpTableLengthInBytes + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $jumpTableLengthInBytes + call $assembly/codec/Decoder#bytes + local.tee $rawJumpTable + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + call $assembly/codec/Decoder#bytes + local.tee $rawCode + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + i32.const 7 + i32.add + i32.const 8 + i32.div_u + call $assembly/codec/Decoder#bytes + local.tee $rawMask + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $rawMask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $jumpTableItemLength + local.get $rawJumpTable + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/program/JumpTable#constructor + local.tee $jumpTable + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $rawCode + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $mask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=28 + local.get $12 + call $assembly/program/BasicBlocks#constructor + local.tee $basicBlocks + i32.store offset=32 + i32.const 0 + local.get $rawCode + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $mask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=28 + local.get $12 + local.get $jumpTable + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=36 + local.get $12 + local.get $basicBlocks + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=40 + local.get $12 + call $assembly/program/Program#constructor + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/decodeArguments (param $kind i32) (param $data i32) (param $lim i32) (result i32) + (local $extended i32) + (local $i i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + global.get $assembly/arguments/REQUIRED_BYTES + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $kind + call $~lib/array/Array#__get + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/arguments/REQUIRED_BYTES + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $kind + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#constructor + local.tee $extended + i32.store offset=4 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $extended + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $extended + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $lim + i32.const 2 + global.set $~argumentsLength + global.get $assembly/arguments/DECODERS + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $kind + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $3) + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $lim + i32.const 2 + global.set $~argumentsLength + global.get $assembly/arguments/DECODERS + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $kind + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $3) + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/api-generic/getAssembly (param $p i32) (result i32) + (local $len i32) + (local $v i32) + (local $i i32) + (local $instruction i32) + (local $iData i32) + (local $6 i32) + (local $skipBytes i32) + (local $args i32) + (local $9 i32) + (local $argsArray i32) + (local $relevantArgs i32) + (local $i|12 i32) + (local $13 i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + local.get $len + i32.const 0 + i32.eq + if + i32.const 16928 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 14400 + local.tee $v + i32.store offset=8 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + call $assembly/program/Mask#isInstruction + i32.eqz + if + i32.const 17008 + i32.const 17120 + i32.const 46 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $instruction + call $~lib/array/Array#__get + end + local.set $iData + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const 17200 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + i32.const 10 + call $~lib/number/I32#toString + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 17232 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/string/String#concat + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $iData + call $assembly/instructions/Instruction#get:namePtr + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $~lib/memory/__stack_pointer + local.get $instruction + i32.const 10 + call $~lib/number/U8#toString + local.tee $6 + i32.store offset=20 + i32.const 17328 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 1 + local.get $6 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 17328 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 14400 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipBytes + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + local.get $i + i32.const 1 + i32.add + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $skipBytes + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + i32.const 42 + i32.const 0 + call $~lib/rt/__newArray + local.tee $9 + i32.store offset=28 + local.get $9 + i32.const 0 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:a + call $~lib/array/Array#__set + local.get $9 + i32.const 1 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:b + call $~lib/array/Array#__set + local.get $9 + i32.const 2 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:c + call $~lib/array/Array#__set + local.get $9 + i32.const 3 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:d + call $~lib/array/Array#__set + local.get $9 + local.tee $argsArray + i32.store offset=32 + global.get $assembly/arguments/RELEVANT_ARGS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $iData + call $assembly/instructions/Instruction#get:kind + call $~lib/array/Array#__get + local.set $relevantArgs + i32.const 0 + local.set $i|12 + loop $for-loop|1 + local.get $i|12 + local.get $relevantArgs + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $~lib/memory/__stack_pointer + local.get $argsArray + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + local.get $i|12 + call $~lib/array/Array#__get + i32.const 10 + call $~lib/number/U32#toString + local.tee $13 + i32.store offset=36 + i32.const 17424 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 1 + local.get $13 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 17424 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 14400 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + local.get $i|12 + i32.const 1 + i32.add + local.set $i|12 + br $for-loop|1 + end + end + local.get $i + local.get $skipBytes + i32.add + local.set $i + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + ) + (func $assembly/codec/Decoder#u24 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 3 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 3 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u16 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 2 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.const 15 + i32.and + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u32 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 4 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 3 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 4 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#isExhausted (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#get:offset + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $assembly/codec/Decoder#get:source + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + i32.ge_s + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $assembly/codec/Decoder#finish (param $this i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + i32.const 17456 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + call $assembly/codec/Decoder#get:source + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/codec/Decoder#get:offset + i32.sub + i32.const 10 + call $~lib/number/I32#toString + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/string/String#concat + i32.const 16384 + i32.const 31 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/decodeSpi (param $data i32) (result i32) + (local $decoder i32) + (local $roLength i32) + (local $rwLength i32) + (local $_heapPages i32) + (local $_stackSize i32) + (local $_roMem i32) + (local $_rwMem i32) + (local $codeLength i32) + (local $code i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#u24 + local.set $roLength + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#u24 + local.set $rwLength + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#u16 + local.set $_heapPages + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#u24 + local.set $_stackSize + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $roLength + call $assembly/codec/Decoder#bytes + local.tee $_roMem + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $rwLength + call $assembly/codec/Decoder#bytes + local.tee $_rwMem + i32.store offset=12 + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#u32 + local.set $codeLength + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $codeLength + call $assembly/codec/Decoder#bytes + local.tee $code + i32.store offset=16 + local.get $decoder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/codec/Decoder#finish + local.get $code + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/program/deblob + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $assembly/index/disassemble (param $input i32) (param $kind i32) (param $withMetadata i32) (result i32) + (local $program i32) + (local $output i32) + (local $data i32) + (local $p i32) + (local $p|7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $input + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/program/liftBytes + local.tee $program + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 14400 + local.tee $output + i32.store offset=8 + local.get $withMetadata + global.get $assembly/index/HasMetadata.Yes + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/program/extractCodeAndMetadata + local.tee $data + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/program/CodeAndMetadata#get:code + local.tee $program + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 16656 + local.tee $output + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $output + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 16704 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String.__concat + local.tee $output + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $output + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=32 + local.get $8 + call $assembly/program/CodeAndMetadata#get:metadata + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=20 + local.get $8 + i32.const 16736 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 14400 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/typedarray/Uint8Array#reduce<~lib/string/String> + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String.__concat + local.tee $output + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $output + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 16768 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String.__concat + local.tee $output + i32.store offset=8 + end + local.get $kind + global.get $assembly/index/InputKind.Generic + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/program/deblob + local.tee $p + i32.store offset=36 + local.get $output + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $p + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=20 + local.get $8 + call $assembly/api-generic/getAssembly + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String.__concat + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $kind + global.get $assembly/index/InputKind.SPI + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/program/decodeSpi + local.tee $p|7 + i32.store offset=40 + local.get $output + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $p|7 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=20 + local.get $8 + call $assembly/api-generic/getAssembly + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String.__concat + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + i32.const 17584 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $bufferSize i32) + (local $buffer i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 43 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:length_ + local.get $length + i32.const 1073741820 + i32.const 3 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8128 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + local.tee $2 + i32.const 8 + local.tee $3 + local.get $2 + local.get $3 + i32.gt_u + select + i32.const 3 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $bufferSize + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $length + call $~lib/array/Array#set:length_ + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $~lib/array/Array#fill (param $this i32) (param $value i64) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.get $value + local.get $start + local.get $end + call $~lib/util/bytes/FILL + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/array/Array#fill@varargs (param $this i32) (param $value i64) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $start + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $value + local.get $start + local.get $end + call $~lib/array/Array#fill + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/api-generic/VmInput#constructor (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 47 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/array/Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i64.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/array/Array#fill@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/api-generic/VmInput#set:registers + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/api-generic/VmInput#set:pc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i64.const 0 + call $assembly/api-generic/VmInput#set:gas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 17632 + call $~lib/rt/__newArray + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/api-generic/VmInput#set:program + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 17664 + call $~lib/rt/__newArray + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/api-generic/VmInput#set:pageMap + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 17696 + call $~lib/rt/__newArray + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/api-generic/VmInput#set:memory + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i64) + (local $value i64) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $"~lib/map/Map#constructor" (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.const 18 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 4 + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + i32.const 1 + i32.sub + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 4 + block $"~lib/map/ENTRY_SIZE|inlined.5" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.5" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesOffset" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/typedarray/Uint8Array.wrap (param $buffer i32) (param $byteOffset i32) (param $length i32) (result i32) + (local $buffer|3 i32) + (local $byteOffset|4 i32) + (local $len i32) + (local $byteLength i32) + (local $bufferByteLength i32) + (local $out i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + block $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) + global.get $~lib/memory/__stack_pointer + local.get $buffer + local.tee $buffer|3 + i32.store + local.get $byteOffset + local.set $byteOffset|4 + local.get $length + local.set $len + local.get $buffer|3 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/arraybuffer/ArrayBuffer#get:byteLength + local.set $bufferByteLength + local.get $byteOffset|4 + local.get $bufferByteLength + i32.gt_u + local.get $byteOffset|4 + i32.const 0 + i32.and + i32.or + if + i32.const 480 + i32.const 720 + i32.const 1860 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $len + i32.const 0 + i32.lt_s + if + local.get $len + i32.const -1 + i32.eq + if + local.get $bufferByteLength + i32.const 0 + i32.and + if + i32.const 8176 + i32.const 720 + i32.const 1865 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + local.get $bufferByteLength + local.get $byteOffset|4 + i32.sub + local.set $byteLength + else + i32.const 8176 + i32.const 720 + i32.const 1869 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + else + local.get $len + i32.const 0 + i32.shl + local.set $byteLength + local.get $byteOffset|4 + local.get $byteLength + i32.add + local.get $bufferByteLength + i32.gt_s + if + i32.const 8176 + i32.const 720 + i32.const 1874 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=8 + local.get $out + local.get $buffer|3 + i32.store + local.get $out + local.get $buffer|3 + i32.const 0 + call $~lib/rt/itcms/__link + local.get $out + local.get $byteLength + i32.store offset=8 + local.get $out + local.get $buffer|3 + local.get $byteOffset|4 + i32.add + i32.store offset=4 + local.get $out + br $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" + end + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $~lib/array/Array#unshift (param $this i32) (param $value i32) (result i32) + (local $len i32) + (local $ptr i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.set $ptr + local.get $ptr + i32.const 4 + i32.add + local.get $ptr + local.get $len + i32.const 1 + i32.sub + i32.const 2 + i32.shl + memory.copy + local.get $ptr + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory-page/Arena#constructor (param $this i32) (param $pageCount i32) (result i32) + (local $2 i32) + (local $data i32) + (local $i i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 16 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:free + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:arenaBytes + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:extraPageIndex + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/memory-page/PAGE_SIZE + local.get $pageCount + i32.mul + call $assembly/memory-page/Arena#set:arenaBytes + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + i32.const 2 + i32.const 17 + i32.const 17728 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory-page/Arena#set:free + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pageCount + call $assembly/memory-page/Arena#set:extraPageIndex + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory-page/Arena#get:arenaBytes + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $data + i32.store offset=12 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pageCount + i32.lt_s + if + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory-page/Arena#get:free + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + local.get $i + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array.wrap + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory-page/RawPage#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/array/Array#unshift + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/memory/MemoryBuilder#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 50 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#constructor" + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/MemoryBuilder#set:pages + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 128 + call $assembly/memory-page/Arena#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/MemoryBuilder#set:arena + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.set $sourceStart + i32.const 0 + i32.eqz + drop + local.get $targetStart + local.get $sourceStart + local.get $sourceLen + i32.const 0 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/MemoryBuilder#setData (param $this i32) (param $access i32) (param $address i32) (param $data i32) (result i32) + (local $currentAddress i32) + (local $currentData i32) + (local $pageIdx i32) + (local $page i32) + (local $relAddress i32) + (local $page|9 i32) + (local $spaceInPage i32) + (local $end i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + local.get $address + local.set $currentAddress + global.get $~lib/memory/__stack_pointer + local.get $data + local.tee $currentData + i32.store + loop $while-continue|0 + local.get $currentData + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + i32.gt_s + if + local.get $currentAddress + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $pageIdx + local.get $pageIdx + global.get $assembly/memory-page/RESERVED_PAGES + i32.lt_u + if + i32.const 17760 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $pageIdx + i32.const 10 + call $~lib/number/U32#toString + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/string/String#concat + i32.const 17856 + i32.const 67 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $assembly/memory/MemoryBuilder#get:pages + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $pageIdx + call $"~lib/map/Map#has" + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $assembly/memory/MemoryBuilder#get:arena + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=12 + local.get $this + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=16 + local.get $12 + call $assembly/memory/MemoryBuilder#get:pages + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $pageIdx + i32.const 0 + local.get $access + local.get $page + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=16 + local.get $12 + call $assembly/memory-page/Page#constructor + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $"~lib/map/Map#set" + drop + end + local.get $currentAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.rem_u + local.set $relAddress + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $assembly/memory/MemoryBuilder#get:pages + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $pageIdx + call $"~lib/map/Map#get" + local.tee $page|9 + i32.store offset=20 + global.get $assembly/memory-page/PAGE_SIZE + local.get $relAddress + i32.sub + local.set $spaceInPage + local.get $currentData + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + local.get $spaceInPage + i32.lt_u + if (result i32) + local.get $currentData + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + else + local.get $spaceInPage + end + local.set $end + local.get $page|9 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=24 + local.get $12 + call $assembly/memory-page/Page#get:raw + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=16 + local.get $12 + call $assembly/memory-page/RawPage#get:data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $currentData + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=16 + local.get $12 + i32.const 0 + local.get $end + call $~lib/typedarray/Uint8Array#subarray + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + local.get $relAddress + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $currentAddress + local.get $end + i32.add + local.set $currentAddress + global.get $~lib/memory/__stack_pointer + local.get $currentData + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $end + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $currentData + i32.store + br $while-continue|0 + end + end + local.get $this + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory/Memory#constructor (param $this i32) (param $arena i32) (param $pages i32) (param $sbrkAddress i32) (result i32) + (local $sbrkPage i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 15 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $arena + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory/Memory#set:arena + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory/Memory#set:pages + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $sbrkAddress + call $assembly/memory/Memory#set:sbrkAddress + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $sbrkAddress + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $sbrkPage + local.get $sbrkPage + global.get $assembly/memory-page/RESERVED_PAGES + i32.lt_u + if + i32.const 17920 + i32.const 17856 + i32.const 104 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $sbrkPage + call $"~lib/map/Map#has" + if (result i32) + local.get $sbrkPage + else + local.get $sbrkPage + i32.const 1 + i32.sub + end + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/memory/MemoryBuilder#build (param $this i32) (param $sbrkAddress i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + i32.const 0 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MemoryBuilder#get:arena + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MemoryBuilder#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $sbrkAddress + call $assembly/memory/Memory#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api-generic/buildMemory (param $builder i32) (param $pages i32) (param $chunks i32) (result i32) + (local $sbrkIndex i32) + (local $i i32) + (local $initPage i32) + (local $i|6 i32) + (local $initChunk i32) + (local $data i32) + (local $i|9 i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $assembly/memory-page/RESERVED_MEMORY + local.set $sbrkIndex + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pages + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/array/Array#get:length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $pages + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $i + call $~lib/array/Array#__get + local.tee $initPage + i32.store offset=4 + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-generic/InitialPage#get:access + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-generic/InitialPage#get:address + i32.const 0 + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-generic/InitialPage#get:length + call $~lib/typedarray/Uint8Array#constructor + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/MemoryBuilder#setData + drop + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/api-generic/InitialPage#get:access + global.get $assembly/memory-page/Access.Write + i32.eq + if + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/api-generic/InitialPage#get:address + local.get $sbrkIndex + i32.lt_u + if (result i32) + local.get $sbrkIndex + else + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/api-generic/InitialPage#get:address + end + local.set $sbrkIndex + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|6 + loop $for-loop|1 + local.get $i|6 + local.get $chunks + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/array/Array#get:length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $chunks + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $i|6 + call $~lib/array/Array#__get + local.tee $initChunk + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $initChunk + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/api-generic/InitialChunk#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $data + i32.store offset=20 + i32.const 0 + local.set $i|9 + loop $for-loop|2 + local.get $i|9 + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $i|9 + local.get $initChunk + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-generic/InitialChunk#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + local.get $i|9 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $i|9 + i32.const 1 + i32.add + local.set $i|9 + br $for-loop|2 + end + end + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + global.get $assembly/memory-page/Access.None + local.get $initChunk + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-generic/InitialChunk#get:address + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/MemoryBuilder#setData + drop + local.get $i|6 + i32.const 1 + i32.add + local.set $i|6 + br $for-loop|1 + end + end + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $sbrkIndex + call $assembly/memory/MemoryBuilder#build + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $assembly/gas/GasCounterU64#constructor (param $this i32) (param $gas i64) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 51 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $gas + call $assembly/gas/GasCounterU64#set:gas + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/interpreter/Interpreter#constructor (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 33 + i32.const 29 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:program + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:registers + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:memory + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:gas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:pc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:exitCode + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:nextPc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:useSbrkGas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/interpreter/Interpreter#set:program + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/interpreter/Interpreter#set:registers + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/interpreter/Interpreter#set:memory + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i64.const 0 + call $assembly/gas/gasCounter + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/interpreter/Interpreter#set:gas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:pc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + global.get $assembly/interpreter/Status.OK + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:exitCode + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:nextPc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:useSbrkGas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/string/String#substring (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $len i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $finalStart i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $finalEnd i32) + (local $14 i32) + (local $15 i32) + (local $fromPos i32) + (local $17 i32) + (local $18 i32) + (local $toPos i32) + (local $size i32) + (local $out i32) + (local $22 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $~lib/string/String#get:length + local.set $len + local.get $start + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + local.tee $6 + local.get $len + local.tee $7 + local.get $6 + local.get $7 + i32.lt_s + select + local.set $finalStart + local.get $end + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_s + select + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + local.set $finalEnd + local.get $finalStart + local.tee $14 + local.get $finalEnd + local.tee $15 + local.get $14 + local.get $15 + i32.lt_s + select + i32.const 1 + i32.shl + local.set $fromPos + local.get $finalStart + local.tee $17 + local.get $finalEnd + local.tee $18 + local.get $17 + local.get $18 + i32.gt_s + select + i32.const 1 + i32.shl + local.set $toPos + local.get $toPos + local.get $fromPos + i32.sub + local.set $size + local.get $size + i32.eqz + if + i32.const 14400 + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + end + local.get $fromPos + i32.eqz + if (result i32) + local.get $toPos + local.get $len + i32.const 1 + i32.shl + i32.eq + else + i32.const 0 + end + if + local.get $this + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + end + global.get $~lib/memory/__stack_pointer + local.get $size + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $out + local.get $this + local.get $fromPos + i32.add + local.get $size + memory.copy + local.get $out + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + ) + (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $value i64) + (local $sepLen i32) + (local $estLen i32) + (local $result i32) + (local $offset i32) + (local $value|9 i64) + (local $i i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 14400 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $lastIndex + i32.eqz + if + local.get $dataStart + i64.load + local.set $value + i32.const 0 + drop + i32.const 8 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 10 + call $~lib/util/number/utoa64 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $separator + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + local.set $sepLen + i32.const 20 + local.get $sepLen + i32.add + local.get $lastIndex + i32.mul + i32.const 20 + i32.add + local.set $estLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=4 + i32.const 0 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $lastIndex + i32.lt_s + if + local.get $dataStart + local.get $i + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $dataStart + local.get $lastIndex + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $estLen + local.get $offset + i32.gt_s + if + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.const 0 + local.get $offset + call $~lib/string/String#substring + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/staticarray/StaticArray#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 0 + drop + i32.const 1 + drop + local.get $this + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/staticarray/StaticArray#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/util/string/joinIntegerArray + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api-generic/runVm~anonymous|0 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 16704 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $x + i32.const 16 + call $~lib/number/U64#toString + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/string/String#concat + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $this i32) (param $fn i32) (result i32) + (local $len i32) + (local $out i32) + (local $outStart i32) + (local $i i32) + (local $result i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/staticarray/StaticArray#get:length + local.set $len + global.get $~lib/memory/__stack_pointer + local.get $len + i32.const 2 + i32.const 52 + i32.const 0 + call $~lib/rt/__newArray + local.tee $out + i32.store offset=4 + local.get $out + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.set $outStart + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.get $i + i32.const 3 + i32.shl + i32.add + i64.load + local.get $i + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + i32.const 3 + global.set $~argumentsLength + local.get $fn + i32.load + call_indirect (type $17) + local.tee $result + i32.store offset=8 + local.get $outStart + local.get $i + i32.const 2 + i32.shl + i32.add + local.get $result + i32.store + i32.const 1 + drop + local.get $out + local.get $result + i32.const 1 + call $~lib/rt/itcms/__link + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $out + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $~lib/array/Array<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) + (local $ptr i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.set $ptr + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array<~lib/string/String>#get:length_ + local.set $len + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + i32.const 1 + i32.lt_s + drop + i32.const 1 + drop + local.get $ptr + local.get $len + local.get $separator + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/util/string/joinStringArray + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-generic/runVm~anonymous|1 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 16704 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $x + i32.const 16 + call $~lib/number/U64#toString + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/string/String#concat + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/program/ResolvedArguments#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.const 54 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:a + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:b + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:c + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:d + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/program/ResolvedArguments#set:decoded + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/program/resolveArguments (param $kind i32) (param $data i32) (param $lim i32) (param $registers i32) (result i32) + (local $args i32) + (local $resolved i32) + (local $6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $kind + local.get $data + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $lim + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=4 + local.get $args + i32.const 0 + i32.eq + if + i32.const 0 + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/program/ResolvedArguments#constructor + local.tee $resolved + i32.store offset=8 + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/program/ResolvedArguments#set:decoded + block $case13|0 + block $case12|0 + block $case11|0 + block $case10|0 + block $case9|0 + block $case8|0 + block $case7|0 + block $case6|0 + block $case5|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $kind + local.set $6 + local.get $6 + global.get $assembly/arguments/Arguments.Zero + i32.eq + br_if $case0|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneImm + i32.eq + br_if $case1|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoImm + i32.eq + br_if $case2|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneOff + i32.eq + br_if $case3|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegOneImm + i32.eq + br_if $case4|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegOneExtImm + i32.eq + br_if $case5|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i32.eq + br_if $case6|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i32.eq + br_if $case7|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoReg + i32.eq + br_if $case8|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i32.eq + br_if $case9|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i32.eq + br_if $case10|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoRegTwoImm + i32.eq + br_if $case11|0 + local.get $6 + global.get $assembly/arguments/Arguments.ThreeReg + i32.eq + br_if $case12|0 + br $case13|0 + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + i64.const 32 + i64.shl + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + i64.add + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:d + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:d + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + i32.const 18528 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $~lib/string/String#concat + i32.const 18608 + i32.const 347 + i32.const 7 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/interpreter/DjumpResult#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 55 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/interpreter/DjumpStatus.OK + call $assembly/interpreter/DjumpResult#set:status + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/interpreter/DjumpResult#set:newPc + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/interpreter/dJump (param $jumpTable i32) (param $address i32) (result i32) + (local $r i32) + (local $index i32) + (local $newPc i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/interpreter/DjumpResult#constructor + local.tee $r + i32.store + local.get $address + global.get $assembly/interpreter/EXIT + i32.eq + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.HALT + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $address + i32.const 0 + i32.eq + if (result i32) + i32.const 1 + else + local.get $address + global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR + i32.rem_u + i32.const 0 + i32.ne + end + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.PANIC + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $address + global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR + i32.div_u + i32.const 1 + i32.sub + local.set $index + local.get $index + local.get $jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/JumpTable#get:jumps + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.PANIC + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/JumpTable#get:jumps + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $index + call $~lib/staticarray/StaticArray#__get + local.set $newPc + local.get $newPc + global.get $assembly/interpreter/MAX_U32 + i64.ge_u + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.PANIC + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $newPc + i32.wrap_i64 + call $assembly/interpreter/DjumpResult#set:newPc + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/interpreter/BranchResult#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 56 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/interpreter/BranchResult#set:isOkay + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/interpreter/BranchResult#set:newPc + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/program/BasicBlocks#isStart (param $this i32) (param $newPc i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $newPc + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i32.lt_u + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $newPc + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.START + i32.and + i32.const 0 + i32.gt_s + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/interpreter/branch (param $basicBlocks i32) (param $pc i32) (param $offset i32) (result i32) + (local $r i32) + (local $newPc i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/interpreter/BranchResult#constructor + local.tee $r + i32.store + local.get $pc + local.get $offset + i32.add + local.set $newPc + local.get $basicBlocks + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $newPc + call $assembly/program/BasicBlocks#isStart + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + call $assembly/interpreter/BranchResult#set:isOkay + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $newPc + call $assembly/interpreter/BranchResult#set:newPc + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/interpreter/Interpreter#nextStep (param $this i32) (result i32) + (local $pc i32) + (local $instruction i32) + (local $iData i32) + (local $skipBytes i32) + (local $args i32) + (local $alloc i64) + (local $gas i64) + (local $exe i32) + (local $outcome i32) + (local $10 i32) + (local $res i32) + (local $branchResult i32) + (local $branchResult|13 i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:status + global.get $assembly/interpreter/Status.HOST + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OK + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:nextPc + call $assembly/interpreter/Interpreter#set:pc + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const -1 + call $assembly/interpreter/Interpreter#set:nextPc + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:status + global.get $assembly/interpreter/Status.OK + i32.ne + if + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:nextPc + i32.const -1 + i32.ne + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:nextPc + call $assembly/interpreter/Interpreter#set:pc + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const -1 + call $assembly/interpreter/Interpreter#set:nextPc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const 0 + call $assembly/interpreter/Interpreter#set:exitCode + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:pc + local.set $pc + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $pc + call $assembly/program/Mask#isInstruction + i32.eqz + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $assembly/instructions/Instruction#get:gas + call $assembly/gas/GasCounter#sub@override + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OOG + call $assembly/interpreter/Interpreter#set:status + else + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + end + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $pc + call $~lib/typedarray/Uint8Array#__get + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/array/Array#get:length + i32.lt_s + if (result i32) + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $instruction + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $iData + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $iData + call $assembly/instructions/Instruction#get:gas + call $assembly/gas/GasCounter#sub@override + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OOG + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $iData + global.get $assembly/instructions/MISSING_INSTRUCTION + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $pc + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipBytes + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + local.get $pc + i32.const 1 + i32.add + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $skipBytes + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=16 + local.get $iData + global.get $assembly/instructions/SBRK + i32.eq + if (result i32) + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:useSbrkGas + else + i32.const 0 + end + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:registers + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + local.set $alloc + local.get $alloc + global.get $assembly/memory-page/PAGE_SIZE + i64.extend_i32_u + i64.add + i64.const 1 + i64.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i64.extend_i32_s + i64.shr_u + i64.const 16 + i64.mul + local.set $gas + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $gas + call $assembly/gas/GasCounter#sub@override + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OOG + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions-exe/RUN + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $instruction + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get + local.tee $exe + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/interpreter/Interpreter#get:registers + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/interpreter/Interpreter#get:memory + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + i32.const 3 + global.set $~argumentsLength + local.get $exe + i32.load + call_indirect (type $2) + local.tee $outcome + i32.store offset=24 + block $break|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:outcome + local.set $10 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.DynamicJump + i32.eq + br_if $case0|0 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.StaticJump + i32.eq + br_if $case1|0 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.Result + i32.eq + br_if $case2|0 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.Ok + i32.eq + br_if $case3|0 + br $break|0 + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:jumpTable + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:dJump + call $assembly/interpreter/dJump + local.tee $res + i32.store offset=28 + local.get $res + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/DjumpResult#get:status + global.get $assembly/interpreter/DjumpStatus.HALT + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.HALT + call $assembly/interpreter/Interpreter#set:status + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $res + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/DjumpResult#get:status + global.get $assembly/interpreter/DjumpStatus.PANIC + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:basicBlocks + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $res + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/DjumpResult#get:newPc + i32.const 0 + call $assembly/interpreter/branch + local.tee $branchResult + i32.store offset=32 + local.get $branchResult + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/BranchResult#get:isOkay + i32.eqz + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $branchResult + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/BranchResult#get:newPc + call $assembly/interpreter/Interpreter#set:pc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:basicBlocks + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $pc + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:staticJump + call $assembly/interpreter/branch + local.tee $branchResult|13 + i32.store offset=36 + local.get $branchResult|13 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/BranchResult#get:isOkay + i32.eqz + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $branchResult|13 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/BranchResult#get:newPc + call $assembly/interpreter/Interpreter#set:pc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.HOST + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.HOST + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + call $assembly/interpreter/Interpreter#set:exitCode + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:pc + i32.const 1 + i32.add + local.get $skipBytes + i32.add + call $assembly/interpreter/Interpreter#set:nextPc + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.FAULT + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i64.const 1 + call $assembly/gas/GasCounter#sub@override + drop + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + global.get $assembly/memory-page/RESERVED_MEMORY + i32.lt_u + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + else + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.FAULT + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + call $assembly/interpreter/Interpreter#set:exitCode + end + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.FAULT_ACCESS + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i64.const 1 + call $assembly/gas/GasCounter#sub@override + drop + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.PANIC + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + call $assembly/interpreter/Interpreter#set:exitCode + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + i32.const 18944 + i32.const 18992 + i32.const 173 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:pc + i32.const 1 + local.get $skipBytes + i32.add + i32.add + call $assembly/interpreter/Interpreter#set:pc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + ) + (func $assembly/api-generic/VmOutput#constructor (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 44 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + global.get $assembly/interpreter/Status.OK + call $assembly/api-generic/VmOutput#set:status + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.const 3 + i32.const 43 + i32.const 19072 + call $~lib/rt/__newArray + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/api-generic/VmOutput#set:registers + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + call $assembly/api-generic/VmOutput#set:pc + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 19104 + call $~lib/rt/__newArray + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/api-generic/VmOutput#set:memory + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i64.const 0 + call $assembly/api-generic/VmOutput#set:gas + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + call $assembly/api-generic/VmOutput#set:exitCode + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#slice<~lib/array/Array> (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $length i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $sourceStart i32) + (local $size i32) + (local $out i32) + (local $outStart i32) + (local $18 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $18 + global.get $~lib/memory/__stack_pointer + local.get $18 + i32.store + local.get $18 + call $~lib/staticarray/StaticArray#get:length + local.set $length + local.get $start + i32.const 0 + i32.lt_s + if (result i32) + local.get $start + local.get $length + i32.add + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + else + local.get $start + local.tee $6 + local.get $length + local.tee $7 + local.get $6 + local.get $7 + i32.lt_s + select + end + local.set $start + local.get $end + i32.const 0 + i32.lt_s + if (result i32) + local.get $end + local.get $length + i32.add + local.tee $8 + i32.const 0 + local.tee $9 + local.get $8 + local.get $9 + i32.gt_s + select + else + local.get $end + local.tee $10 + local.get $length + local.tee $11 + local.get $10 + local.get $11 + i32.lt_s + select + end + local.set $end + local.get $end + local.get $start + i32.sub + local.tee $12 + i32.const 0 + local.tee $13 + local.get $12 + local.get $13 + i32.gt_s + select + local.set $length + local.get $this + local.get $start + i32.const 3 + i32.shl + i32.add + local.set $sourceStart + local.get $length + i32.const 3 + i32.shl + local.set $size + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $out + i32.store offset=4 + i32.const 1 + drop + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 3 + i32.const 43 + i32.const 0 + call $~lib/rt/__newArray + local.tee $out + i32.store offset=4 + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + local.get $18 + i32.store + local.get $18 + call $~lib/array/Array#get:dataStart + local.set $outStart + i32.const 0 + drop + local.get $outStart + local.get $sourceStart + local.get $size + memory.copy + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + ) + (func $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $start + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $start + local.get $end + call $~lib/staticarray/StaticArray#slice<~lib/array/Array> + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $bufferSize i32) + (local $buffer i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 42 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:length_ + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8128 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + local.tee $2 + i32.const 8 + local.tee $3 + local.get $2 + local.get $3 + i32.gt_u + select + i32.const 2 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $bufferSize + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $length + call $~lib/array/Array#set:length_ + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.get $newLength + i32.const 2 + i32.const 0 + call $~lib/array/ensureCapacity + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $newLength + call $~lib/array/Array#set:length_ + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#keys" (param $this i32) (result i32) + (local $start i32) + (local $size i32) + (local $keys i32) + (local $length i32) + (local $i i32) + (local $entry i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.set $start + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.set $size + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $size + call $~lib/array/Array#constructor + local.tee $keys + i32.store offset=4 + i32.const 0 + local.set $length + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $size + i32.lt_s + if + local.get $start + local.get $i + block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.6" + end + i32.mul + i32.add + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $keys + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + local.tee $7 + i32.const 1 + i32.add + local.set $length + local.get $7 + local.get $entry + call $"~lib/map/MapEntry#get:key" + call $~lib/array/Array#__set + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $keys + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + call $~lib/array/Array#set:length + local.get $keys + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 0 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-generic/InitialChunk#constructor (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 45 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + call $assembly/api-generic/InitialChunk#set:address + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 19168 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/api-generic/InitialChunk#set:data + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + i32.const 0 + drop + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 1 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-generic/getOutputChunks (param $memory i32) (result i32) + (local $1 i32) + (local $chunks i32) + (local $pages i32) + (local $currentChunk i32) + (local $i i32) + (local $pageIdx i32) + (local $page i32) + (local $n i32) + (local $v i32) + (local $10 i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 19136 + call $~lib/rt/__newArray + local.tee $chunks + i32.store + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory/Memory#get:pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $"~lib/map/Map#keys" + local.tee $pages + i32.store offset=12 + i32.const 0 + local.set $currentChunk + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/array/Array#get:length + i32.lt_s + if + block $for-continue|0 + local.get $pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $i + call $~lib/array/Array#__get + local.set $pageIdx + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory/Memory#get:pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $pageIdx + call $"~lib/map/Map#get" + local.tee $page + i32.store offset=16 + local.get $page + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory-page/Page#get:raw + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $assembly/memory-page/RawPage#get:page + i32.const 0 + i32.eq + if + br $for-continue|0 + end + i32.const 0 + local.set $n + loop $for-loop|1 + local.get $n + local.get $page + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=20 + local.get $11 + call $assembly/memory-page/Page#get:raw + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory-page/RawPage#get:data + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $page + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=20 + local.get $11 + call $assembly/memory-page/Page#get:raw + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory-page/RawPage#get:data + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + i32.const 0 + i32.ne + if + local.get $currentChunk + i32.const 0 + i32.ne + if + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/api-generic/InitialChunk#get:data + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $v + call $~lib/array/Array#push + drop + else + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-generic/InitialChunk#constructor + local.tee $currentChunk + i32.store offset=24 + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $pageIdx + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.get $n + i32.add + call $assembly/api-generic/InitialChunk#set:address + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + global.get $~lib/memory/__stack_pointer + i32.const 1 + i32.const 0 + i32.const 27 + i32.const 0 + call $~lib/rt/__newArray + local.tee $10 + i32.store offset=28 + local.get $10 + i32.const 0 + local.get $v + call $~lib/array/Array#__set + local.get $10 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/api-generic/InitialChunk#set:data + end + else + local.get $currentChunk + i32.const 0 + i32.ne + if + local.get $chunks + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $~lib/array/Array#push + drop + i32.const 0 + local.set $currentChunk + end + end + local.get $n + i32.const 1 + i32.add + local.set $n + br $for-loop|1 + end + end + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $currentChunk + i32.const 0 + i32.ne + if + local.get $chunks + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $~lib/array/Array#push + drop + end + local.get $chunks + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $bufferSize i32) + (local $buffer i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 57 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:length_ + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8128 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + local.tee $2 + i32.const 8 + local.tee $3 + local.get $2 + local.get $3 + i32.gt_u + select + i32.const 2 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $bufferSize + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $length + call $~lib/array/Array#set:length_ + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.get $newLength + i32.const 2 + i32.const 0 + call $~lib/array/ensureCapacity + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $newLength + call $~lib/array/Array#set:length_ + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#values" (param $this i32) (result i32) + (local $start i32) + (local $size i32) + (local $values i32) + (local $length i32) + (local $i i32) + (local $entry i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.set $start + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.set $size + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $size + call $~lib/array/Array#constructor + local.tee $values + i32.store offset=4 + i32.const 0 + local.set $length + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $size + i32.lt_s + if + local.get $start + local.get $i + block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.7" + end + i32.mul + i32.add + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + local.tee $7 + i32.const 1 + i32.add + local.set $length + local.get $7 + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/array/Array#__set + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + call $~lib/array/Array#set:length + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 16800 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 1 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory-page/Arena#release (param $this i32) (param $page i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory-page/Arena#get:free + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $page + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/array/Array#push + drop + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#clear" (param $this i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + i32.const 4 + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 4 + i32.const 1 + i32.sub + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + i32.const 4 + block $"~lib/map/ENTRY_SIZE|inlined.8" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.8" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 4 + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesOffset" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesCount" + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#free (param $this i32) + (local $pages i32) + (local $i i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory/Memory#get:pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $"~lib/map/Map#values" + local.tee $pages + i32.store offset=8 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + i32.lt_s + if + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/memory/Memory#get:arena + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + local.get $i + call $~lib/array/Array#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/memory-page/Page#get:raw + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#release + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory/Memory#get:pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $"~lib/map/Map#clear" + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/runVm (param $input i32) (param $logs i32) (param $useSbrkGas i32) (result i32) + (local $p i32) + (local $registers i32) + (local $r i32) + (local $builder i32) + (local $memory i32) + (local $int i32) + (local $isOk i32) + (local $10 i32) + (local $11 i32) + (local $instruction i32) + (local $iData i32) + (local $skipBytes i32) + (local $name i32) + (local $16 i32) + (local $17 i32) + (local $args i32) + (local $19 i32) + (local $20 i32) + (local $21 i32) + (local $22 i32) + (local $23 i32) + (local $24 i32) + (local $25 i32) + (local $26 i32) + (local $27 i32) + (local $28 i32) + (local $29 i32) + (local $30 i32) + (local $output i32) + (local $32 i32) + global.get $~lib/memory/__stack_pointer + i32.const 124 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 124 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/api-generic/VmInput#get:program + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/liftBytes + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $assembly/program/deblob + local.tee $p + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=16 + i32.const 0 + local.set $r + loop $for-loop|0 + local.get $r + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $r + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/api-generic/VmInput#get:registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $r + call $~lib/array/Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $r + i32.const 1 + i32.add + local.set $r + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/api-generic/VmInput#get:pageMap + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/api-generic/VmInput#get:memory + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/api-generic/buildMemory + local.tee $memory + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $p + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $memory + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/interpreter/Interpreter#constructor + local.tee $int + i32.store offset=32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $useSbrkGas + call $assembly/interpreter/Interpreter#set:useSbrkGas + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/api-generic/VmInput#get:pc + call $assembly/interpreter/Interpreter#set:nextPc + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:gas + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $input + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/api-generic/VmInput#get:gas + call $assembly/gas/GasCounter#set@override + i32.const 1 + local.set $isOk + block $for-break1 + loop $for-loop|1 + i32.const 1 + if + local.get $isOk + i32.eqz + if + local.get $logs + if + global.get $~lib/memory/__stack_pointer + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 17392 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray#join + local.tee $10 + i32.store offset=36 + i32.const 18128 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 1 + local.get $10 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18128 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 14400 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + global.get $~lib/memory/__stack_pointer + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + i32.const 18192 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=40 + local.get $32 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 17392 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/array/Array<~lib/string/String>#join + local.tee $11 + i32.store offset=44 + i32.const 18160 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 1 + local.get $11 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18160 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 14400 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 18224 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:status + i32.const 10 + call $~lib/number/I32#toString + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/string/String#concat + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + br $for-break1 + end + local.get $logs + if + i32.const 18288 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + i32.const 10 + call $~lib/number/U32#toString + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/string/String#concat + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 18320 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:status + i32.const 10 + call $~lib/number/I32#toString + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/string/String#concat + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 18032 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + i32.const 17392 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=40 + local.get $32 + call $~lib/staticarray/StaticArray#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/string/String#concat + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 18032 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + local.get $registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=48 + local.get $32 + i32.const 18368 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=52 + local.get $32 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + i32.const 17392 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=40 + local.get $32 + call $~lib/array/Array<~lib/string/String>#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/string/String#concat + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + local.get $logs + if + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/interpreter/Interpreter#get:program + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/Program#get:code + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_u + if (result i32) + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/interpreter/Interpreter#get:program + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/Program#get:code + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + call $~lib/typedarray/Uint8Array#__get + else + i32.const 0 + end + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $instruction + call $~lib/array/Array#__get + end + local.set $iData + local.get $p + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/Program#get:mask + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipBytes + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:namePtr + local.tee $name + i32.store offset=56 + global.get $~lib/memory/__stack_pointer + local.get $name + local.tee $16 + i32.store offset=60 + global.get $~lib/memory/__stack_pointer + local.get $instruction + i32.const 10 + call $~lib/number/U8#toString + local.tee $17 + i32.store offset=64 + i32.const 18480 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 1 + local.get $16 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18480 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 3 + local.get $17 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18480 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 14400 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=40 + local.get $32 + call $assembly/interpreter/Interpreter#get:program + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/program/Program#get:code + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + i32.const 1 + i32.add + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $skipBytes + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/interpreter/Interpreter#get:registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/resolveArguments + local.tee $args + i32.store offset=68 + local.get $args + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:a + i32.const 10 + call $~lib/number/I64#toString + local.tee $19 + i32.store offset=72 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/program/ResolvedArguments#get:decoded + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/arguments/Args#get:a + i32.const 10 + call $~lib/number/U32#toString + local.tee $20 + i32.store offset=76 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:a + i32.const 16 + call $~lib/number/U64#toString + local.tee $21 + i32.store offset=80 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:b + i32.const 10 + call $~lib/number/I64#toString + local.tee $22 + i32.store offset=84 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/program/ResolvedArguments#get:decoded + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/arguments/Args#get:b + i32.const 10 + call $~lib/number/U32#toString + local.tee $23 + i32.store offset=88 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:b + i32.const 16 + call $~lib/number/U64#toString + local.tee $24 + i32.store offset=92 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:c + i32.const 10 + call $~lib/number/I64#toString + local.tee $25 + i32.store offset=96 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/program/ResolvedArguments#get:decoded + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/arguments/Args#get:c + i32.const 10 + call $~lib/number/U32#toString + local.tee $26 + i32.store offset=100 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:c + i32.const 16 + call $~lib/number/U64#toString + local.tee $27 + i32.store offset=104 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:d + i32.const 10 + call $~lib/number/I64#toString + local.tee $28 + i32.store offset=108 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/program/ResolvedArguments#get:decoded + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/arguments/Args#get:d + i32.const 10 + call $~lib/number/U32#toString + local.tee $29 + i32.store offset=112 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/program/ResolvedArguments#get:d + i32.const 16 + call $~lib/number/U64#toString + local.tee $30 + i32.store offset=116 + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 1 + local.get $19 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 3 + local.get $20 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 5 + local.get $21 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 7 + local.get $22 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 9 + local.get $23 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 11 + local.get $24 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 13 + local.get $25 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 15 + local.get $26 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 17 + local.get $27 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 19 + local.get $28 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 21 + local.get $29 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 23 + local.get $30 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18816 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + i32.const 14400 + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $~lib/console/console.log + end + end + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $assembly/interpreter/Interpreter#nextStep + local.set $isOk + br $for-loop|1 + end + end + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-generic/VmOutput#constructor + local.tee $output + i32.store offset=120 + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:status + call $assembly/api-generic/VmOutput#set:status + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:registers + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/api-generic/VmOutput#set:registers + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:pc + call $assembly/api-generic/VmOutput#set:pc + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/interpreter/Interpreter#get:gas + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/gas/GasCounter#get@override + call $assembly/api-generic/VmOutput#set:gas + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=24 + local.get $32 + call $assembly/interpreter/Interpreter#get:memory + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=8 + local.get $32 + call $assembly/api-generic/getOutputChunks + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/api-generic/VmOutput#set:memory + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:exitCode + call $assembly/api-generic/VmOutput#set:exitCode + local.get $int + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store offset=4 + local.get $32 + call $assembly/interpreter/Interpreter#get:memory + local.set $32 + global.get $~lib/memory/__stack_pointer + local.get $32 + i32.store + local.get $32 + call $assembly/memory/Memory#free + local.get $output + local.set $32 + global.get $~lib/memory/__stack_pointer + i32.const 124 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $32 + return + ) + (func $assembly/index/runProgram (param $input i32) (param $registers i32) (param $kind i32) (result i32) + (local $vmInput i32) + (local $output i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $kind + global.get $assembly/index/InputKind.Generic + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-generic/VmInput#constructor + local.tee $vmInput + i32.store + local.get $vmInput + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/api-generic/VmInput#set:registers + local.get $vmInput + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i64.const 10000 + call $assembly/api-generic/VmInput#set:gas + local.get $vmInput + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $input + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/api-generic/VmInput#set:program + global.get $~lib/memory/__stack_pointer + local.get $vmInput + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + i32.const 0 + call $assembly/api-generic/runVm + local.tee $output + i32.store offset=12 + i32.const 18224 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $output + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/api-generic/VmOutput#get:status + i32.const 10 + call $~lib/number/I32#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $~lib/string/String#concat + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/console/console.log + local.get $output + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $kind + global.get $assembly/index/InputKind.SPI + i32.eq + if + i32.const 19200 + i32.const 19280 + i32.const 57 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + i32.const 17584 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/string/String#concat + i32.const 19280 + i32.const 60 + i32.const 3 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api-generic/runVm@varargs (param $input i32) (param $logs i32) (param $useSbrkGas i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $logs + end + i32.const 0 + local.set $useSbrkGas + end + local.get $input + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $logs + local.get $useSbrkGas + call $assembly/api-generic/runVm + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program-build/skipBytes (param $kind i32) (param $data i32) (result i32) + (local $2 i32) + (local $n i32) + (local $split i32) + (local $n|5 i32) + (local $split|6 i32) + (local $n|7 i32) + (local $split|8 i32) + (local $value1 f64) + (local $value2 f64) + (local $value1|11 f64) + (local $value2|12 f64) + (local $n|13 i32) + (local $split|14 i32) + (local $15 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $case13|0 + block $case12|0 + block $case11|0 + block $case10|0 + block $case9|0 + block $case8|0 + block $case7|0 + block $case6|0 + block $case5|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $kind + local.set $2 + local.get $2 + global.get $assembly/arguments/Arguments.Zero + i32.eq + br_if $case0|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneImm + i32.eq + br_if $case1|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoImm + i32.eq + br_if $case2|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneOff + i32.eq + br_if $case3|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegOneImm + i32.eq + br_if $case4|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegOneExtImm + i32.eq + br_if $case5|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i32.eq + br_if $case6|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i32.eq + br_if $case7|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoReg + i32.eq + br_if $case8|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i32.eq + br_if $case9|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i32.eq + br_if $case10|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoRegTwoImm + i32.eq + br_if $case11|0 + local.get $2 + global.get $assembly/arguments/Arguments.ThreeReg + i32.eq + br_if $case12|0 + br $case13|0 + end + i32.const 0 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + call $assembly/program-build/immBytes + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:low + i32.const 1 + i32.add + local.set $split + i32.const 1 + local.get $split + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + local.get $split + i32.const 1 + i32.add + i32.const 255 + i32.and + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + call $assembly/program-build/immBytes + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 9 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n|5 + i32.store offset=8 + local.get $n|5 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:hig + i32.const 1 + i32.add + local.set $split|6 + i32.const 1 + local.get $split|6 + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + local.get $split|6 + i32.const 255 + i32.and + i32.add + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n|7 + i32.store offset=12 + local.get $n|7 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:hig + i32.const 1 + i32.add + local.set $split|8 + i32.const 1 + local.get $split|8 + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + local.get $split|8 + i32.const 255 + i32.and + i32.add + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + block $~lib/math/NativeMath.min|inlined.5 (result f64) + f64.const 4 + local.set $value1 + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.5 + end + i32.trunc_sat_f64_s + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + block $~lib/math/NativeMath.min|inlined.6 (result f64) + f64.const 4 + local.set $value1|11 + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + local.set $value2|12 + local.get $value1|11 + local.get $value2|12 + f64.min + br $~lib/math/NativeMath.min|inlined.6 + end + i32.trunc_sat_f64_s + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n|13 + i32.store offset=16 + local.get $n|13 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:low + i32.const 1 + i32.add + local.set $split|14 + i32.const 2 + local.get $split|14 + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 2 + local.get $split|14 + i32.const 255 + i32.and + i32.add + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 2 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 18528 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store offset=20 + local.get $15 + call $~lib/string/String#concat + i32.const 19344 + i32.const 73 + i32.const 7 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program-build/buildMask (param $bytecode i32) (result i32) + (local $mask i32) + (local $i i32) + (local $instruction i32) + (local $iData i32) + (local $requiredBytes i32) + (local $6 i32) + (local $packed i32) + (local $i|8 i32) + (local $byte i32) + (local $j i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + call $~lib/staticarray/StaticArray#constructor + local.tee $mask + i32.store offset=4 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/array/Array#get:length + i32.lt_s + if (result i32) + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $instruction + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $iData + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $i + i32.const 1 + call $~lib/staticarray/StaticArray#__set + global.get $assembly/arguments/REQUIRED_BYTES + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $iData + call $assembly/instructions/Instruction#get:kind + call $~lib/array/Array#__get + local.set $requiredBytes + local.get $i + i32.const 1 + i32.add + local.get $requiredBytes + i32.add + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + i32.le_s + if + local.get $i + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + local.get $i + i32.const 1 + i32.add + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $assembly/program-build/skipBytes + i32.add + local.set $i + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 19424 + call $~lib/rt/__newArray + local.tee $packed + i32.store offset=12 + i32.const 0 + local.set $i|8 + loop $for-loop|1 + local.get $i|8 + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + i32.const 0 + local.set $byte + local.get $i|8 + local.set $j + loop $for-loop|3 + local.get $j + local.get $i|8 + i32.const 8 + i32.add + i32.lt_s + if + local.get $byte + i32.const 255 + i32.and + i32.const 1 + i32.const 7 + i32.and + i32.shr_u + local.set $byte + local.get $j + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if (result i32) + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $j + call $~lib/staticarray/StaticArray#__get + else + i32.const 0 + end + if + local.get $byte + i32.const 128 + i32.or + local.set $byte + end + local.get $j + i32.const 1 + i32.add + local.set $j + br $for-loop|3 + end + end + local.get $packed + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $byte + call $~lib/array/Array#push + drop + local.get $i|8 + i32.const 8 + i32.add + local.set $i|8 + br $for-loop|1 + end + end + local.get $packed + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/dataview/DataView#constructor (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) + (local $dataStart i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 59 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $~lib/dataview/DataView#set:buffer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $~lib/dataview/DataView#set:dataStart + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $~lib/dataview/DataView#set:byteLength + local.get $byteLength + i32.const 1073741820 + i32.gt_u + local.get $byteOffset + local.get $byteLength + i32.add + local.get $buffer + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/arraybuffer/ArrayBuffer#get:byteLength + i32.gt_u + i32.or + if + i32.const 8176 + i32.const 19456 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $buffer + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/dataview/DataView#set:buffer + local.get $buffer + local.get $byteOffset + i32.add + local.set $dataStart + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $dataStart + call $~lib/dataview/DataView#set:dataStart + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $byteLength + call $~lib/dataview/DataView#set:byteLength + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $~lib/dataview/DataView#constructor@varargs (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $byteOffset + end + local.get $buffer + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/arraybuffer/ArrayBuffer#get:byteLength + local.set $byteLength + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $buffer + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $byteOffset + local.get $byteLength + call $~lib/dataview/DataView#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/dataview/DataView#setUint64 (param $this i32) (param $byteOffset i32) (param $value i64) (param $littleEndian i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $byteOffset + i32.const 31 + i32.shr_u + local.get $byteOffset + i32.const 8 + i32.add + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/dataview/DataView#get:byteLength + i32.gt_s + i32.or + if + i32.const 480 + i32.const 19456 + i32.const 174 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/dataview/DataView#get:dataStart + local.get $byteOffset + i32.add + local.get $littleEndian + if (result i64) + local.get $value + else + local.get $value + call $~lib/polyfills/bswap + end + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/encodeVarU32 (param $v i64) (result i32) + (local $maxEncoded i64) + (local $dest i32) + (local $dataView i32) + (local $minEncoded i64) + (local $l i32) + (local $dest|6 i32) + (local $maxVal i32) + (local $byte i64) + (local $rest i64) + (local $i i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + local.get $v + i64.const 0 + i64.eq + if + i32.const 0 + i32.const 1 + call $~lib/typedarray/Uint8Array#constructor + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + i64.const 2 + i64.const 7 + i64.const 8 + i64.mul + call $~lib/math/ipow64 + local.set $maxEncoded + local.get $v + local.get $maxEncoded + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 9 + call $~lib/typedarray/Uint8Array#constructor + local.tee $dest + i32.store + local.get $dest + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + i32.const 255 + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $dest + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/dataview/DataView#constructor@varargs + local.tee $dataView + i32.store offset=12 + local.get $dataView + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 1 + local.get $v + i32.const 1 + call $~lib/dataview/DataView#setUint64 + local.get $dest + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $maxEncoded + i64.const 7 + i64.shr_u + local.set $minEncoded + i32.const 7 + local.set $l + loop $for-loop|0 + local.get $l + i32.const 0 + i32.ge_s + if + local.get $v + local.get $minEncoded + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $l + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $dest|6 + i32.store offset=16 + i32.const 2 + i32.const 8 + local.get $l + i32.mul + call $~lib/math/ipow32 + local.set $maxVal + i32.const 2 + i32.const 8 + call $~lib/math/ipow32 + i32.const 2 + i32.const 8 + local.get $l + i32.sub + call $~lib/math/ipow32 + i32.sub + i64.extend_i32_s + local.get $v + local.get $maxVal + i64.extend_i32_s + i64.div_u + i64.add + local.set $byte + local.get $dest|6 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + local.get $byte + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + local.get $maxVal + i64.extend_i32_s + i64.rem_u + local.set $rest + i32.const 1 + local.set $i + loop $for-loop|1 + local.get $i + i32.const 1 + local.get $l + i32.add + i32.lt_s + if + local.get $dest|6 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $i + local.get $rest + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $rest + i64.const 8 + i64.shr_u + local.set $rest + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|1 + end + end + local.get $dest|6 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $minEncoded + local.set $maxEncoded + local.get $minEncoded + i64.const 7 + i64.shr_u + local.set $minEncoded + local.get $l + i32.const 1 + i32.sub + local.set $l + br $for-loop|0 + end + end + i32.const 19520 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $v + i32.const 10 + call $~lib/number/U64#toString + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $~lib/string/String#concat + i32.const 16384 + i32.const 160 + i32.const 3 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/program-build/wrapAsProgram (param $bytecode i32) (result i32) + (local $codeLength i32) + (local $mask i32) + (local $codeLengthBytes i32) + (local $data i32) + (local $offset i32) + (local $i i32) + (local $i|7 i32) + (local $i|8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + local.get $bytecode + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.set $codeLength + global.get $~lib/memory/__stack_pointer + local.get $bytecode + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $assembly/program-build/buildMask + local.tee $mask + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $codeLength + i64.extend_i32_s + call $assembly/codec/encodeVarU32 + local.tee $codeLengthBytes + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 1 + i32.add + local.get $codeLengthBytes + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.add + local.get $codeLength + i32.add + local.get $mask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/array/Array#get:length + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $data + i32.store offset=12 + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + i32.const 2 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $codeLengthBytes + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $offset + local.get $codeLengthBytes + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $offset + i32.const 1 + i32.add + local.set $offset + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $bytecode + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $offset + local.get $bytecode + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + local.get $i|7 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $offset + i32.const 1 + i32.add + local.set $offset + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + i32.const 0 + local.set $i|8 + loop $for-loop|2 + local.get $i|8 + local.get $mask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/array/Array#get:length + i32.lt_s + if + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $offset + local.get $mask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + local.get $i|8 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $offset + i32.const 1 + i32.add + local.set $offset + local.get $i|8 + i32.const 1 + i32.add + local.set $i|8 + br $for-loop|2 + end + end + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $assembly/api/fillRegisters (param $registers i32) (param $flat i32) + (local $len i32) + (local $3 i32) + (local $4 i32) + (local $i i32) + (local $num i64) + (local $j i32) + (local $index i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/staticarray/StaticArray#get:length + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + local.set $len + local.get $len + local.get $flat + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/array/Array#get:length + i32.ne + if + global.get $~lib/memory/__stack_pointer + local.get $flat + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/array/Array#get:length + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $len + i32.const 10 + call $~lib/number/I32#toString + local.tee $4 + i32.store offset=8 + i32.const 19744 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 1 + local.get $3 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 19744 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 3 + local.get $4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 19744 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 14400 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 19792 + i32.const 166 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $registers + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + i64.const 0 + local.set $num + i32.const 0 + local.set $j + loop $for-loop|1 + local.get $j + global.get $assembly/registers/REG_SIZE_BYTES + i32.const 255 + i32.and + i32.lt_u + if + local.get $i + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + local.get $j + i32.add + local.set $index + local.get $num + local.get $flat + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $index + call $~lib/array/Array#__get + i64.extend_i32_u + local.get $j + i32.const 8 + i32.mul + i32.const 255 + i32.and + i64.extend_i32_u + i64.shl + i64.or + local.set $num + local.get $j + i32.const 1 + i32.add + local.set $j + br $for-loop|1 + end + end + local.get $registers + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $i + local.get $num + call $~lib/staticarray/StaticArray#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/interpreter/Interpreter#constructor@varargs (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 2 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $assembly/memory/MemoryBuilder#build + local.tee $memory + i32.store offset=4 + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/interpreter/Interpreter#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/api/resetGeneric (param $program i32) (param $flatRegisters i32) (param $initialGas i64) + (local $p i32) + (local $registers i32) + (local $int i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + call $assembly/program/liftBytes + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $assembly/program/deblob + local.tee $p + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=12 + local.get $registers + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $flatRegisters + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + call $assembly/api/fillRegisters + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $p + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $registers + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 2 + global.set $~argumentsLength + i32.const 0 + call $assembly/interpreter/Interpreter#constructor@varargs + local.tee $int + i32.store offset=16 + local.get $int + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + call $assembly/interpreter/Interpreter#get:gas + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $initialGas + call $assembly/gas/GasCounter#set@override + local.get $int + global.set $assembly/api/interpreter + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/InitialPage#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 48 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/api-generic/InitialPage#set:address + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/api-generic/InitialPage#set:length + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/memory-page/Access.None + call $assembly/api-generic/InitialPage#set:access + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 1 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api/readPages (param $pageMap i32) (result i32) + (local $1 i32) + (local $pages i32) + (local $codec i32) + (local $p i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 19856 + call $~lib/rt/__newArray + local.tee $pages + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $pageMap + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $codec + i32.store offset=8 + loop $while-continue|0 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-generic/InitialPage#constructor + local.tee $p + i32.store offset=12 + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/codec/Decoder#u32 + call $assembly/api-generic/InitialPage#set:address + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/codec/Decoder#u32 + call $assembly/api-generic/InitialPage#set:length + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/codec/Decoder#u8 + i32.const 0 + i32.gt_u + if (result i32) + global.get $assembly/memory-page/Access.Write + else + global.get $assembly/memory-page/Access.Read + end + call $assembly/api-generic/InitialPage#set:access + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $~lib/array/Array#push + drop + br $while-continue|0 + end + end + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/api/readChunks (param $chunks i32) (result i32) + (local $1 i32) + (local $res i32) + (local $codec i32) + (local $c i32) + (local $len i32) + (local $data i32) + (local $i i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 19888 + call $~lib/rt/__newArray + local.tee $res + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $chunks + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $codec + i32.store offset=8 + loop $while-continue|0 + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-generic/InitialChunk#constructor + local.tee $c + i32.store offset=12 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $assembly/codec/Decoder#u32 + call $assembly/api-generic/InitialChunk#set:address + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/codec/Decoder#u32 + local.set $len + global.get $~lib/memory/__stack_pointer + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $len + call $assembly/codec/Decoder#bytes + local.tee $data + i32.store offset=20 + i32.const 0 + local.set $i + loop $for-loop|1 + local.get $i + local.get $len + i32.lt_u + if + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $assembly/api-generic/InitialChunk#get:data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#push + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/array/Array#push + drop + br $while-continue|0 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/api/resetGenericWithMemory (param $program i32) (param $flatRegisters i32) (param $pageMap i32) (param $chunks i32) (param $initialGas i64) + (local $p i32) + (local $registers i32) + (local $builder i32) + (local $memory i32) + (local $int i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $assembly/program/liftBytes + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/program/deblob + local.tee $p + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=12 + local.get $registers + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $flatRegisters + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $assembly/api/fillRegisters + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $pageMap + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=24 + local.get $10 + call $assembly/api/readPages + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $chunks + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=24 + local.get $10 + call $assembly/api/readChunks + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=20 + local.get $10 + call $assembly/api-generic/buildMemory + local.tee $memory + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $p + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $registers + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $memory + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=20 + local.get $10 + call $assembly/interpreter/Interpreter#constructor + local.tee $int + i32.store offset=32 + local.get $int + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $assembly/interpreter/Interpreter#get:gas + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $initialGas + call $assembly/gas/GasCounter#set@override + local.get $int + global.set $assembly/api/interpreter + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/nextStep (result i32) + (local $0 i32) + (local $int i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 19792 + i32.const 43 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/interpreter/Interpreter#nextStep + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api/nSteps (param $steps i32) (result i32) + (local $1 i32) + (local $int i32) + (local $isOk i32) + (local $i i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 51 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + i32.const 1 + local.set $isOk + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $steps + i32.lt_u + if + local.get $int + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/interpreter/Interpreter#nextStep + local.set $isOk + local.get $isOk + i32.eqz + if + i32.const 0 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $isOk + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + i32.const 0 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/api/getProgramCounter (result i32) + (local $0 i32) + (local $int i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 19792 + i32.const 68 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/interpreter/Interpreter#get:pc + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api/setNextProgramCounter (param $pc i32) + (local $1 i32) + (local $int i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 76 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $pc + call $assembly/interpreter/Interpreter#set:nextPc + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/getStatus (result i32) + (local $0 i32) + (local $int i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + global.get $assembly/interpreter/Status.PANIC + i32.const 255 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 19792 + i32.const 84 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/interpreter/Interpreter#get:status + i32.const 255 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api/getExitArg (result i32) + (local $0 i32) + (local $int i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + i32.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 19792 + i32.const 92 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/interpreter/Interpreter#get:exitCode + local.tee $2 + if (result i32) + local.get $2 + else + i32.const 0 + end + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/api/getGasLeft (result i64) + (local $0 i32) + (local $int i32) + (local $2 i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + i64.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 19792 + i32.const 100 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + call $assembly/interpreter/Interpreter#get:gas + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/gas/GasCounter#get@override + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/api/setGasLeft (param $gas i64) + (local $1 i32) + (local $int i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 106 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/interpreter/Interpreter#get:gas + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $gas + call $assembly/gas/GasCounter#set@override + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/getRegisters (result i32) + (local $flat i32) + (local $1 i32) + (local $int i32) + (local $i i32) + (local $val i64) + (local $j i32) + (local $index i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + call $~lib/typedarray/Uint8Array#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.tee $flat + i32.store offset=4 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + local.get $flat + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store offset=8 + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 117 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=12 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $int + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/interpreter/Interpreter#get:registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + local.get $int + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/interpreter/Interpreter#get:registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $i + call $~lib/staticarray/StaticArray#__get + local.set $val + i32.const 0 + local.set $j + loop $for-loop|1 + local.get $j + global.get $assembly/registers/REG_SIZE_BYTES + i32.lt_s + if + local.get $i + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + local.get $j + i32.add + local.set $index + local.get $flat + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $index + local.get $val + i64.const 255 + i64.and + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $val + i64.const 8 + i64.shr_u + local.set $val + local.get $j + i32.const 1 + i32.add + local.set $j + br $for-loop|1 + end + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $flat + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $assembly/api/setRegisters (param $flatRegisters i32) + (local $1 i32) + (local $int i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 134 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + call $assembly/interpreter/Interpreter#get:registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $flatRegisters + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/api/fillRegisters + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#pageDump (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory/Memory#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $index + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + call $assembly/memory/Memory#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + local.get $index + call $"~lib/map/Map#get" + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory-page/Page#get:raw + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:data + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api/getPageDump (param $index i32) (result i32) + (local $1 i32) + (local $int i32) + (local $page i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store offset=4 + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 19792 + i32.const 142 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $int + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/interpreter/Interpreter#get:memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $index + call $assembly/memory/Memory#pageDump + local.tee $page + i32.store offset=16 + local.get $page + i32.const 0 + i32.eq + if + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $page + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api/setMemory (param $address i32) (param $data i32) + (local $2 i32) + (local $int i32) + (local $end i32) + (local $i i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + i32.const 0 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $2 + i32.store + local.get $2 + if (result i32) + local.get $2 + else + i32.const 9488 + i32.const 19792 + i32.const 155 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $address + local.get $data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $~lib/typedarray/Uint8Array#get:length + i32.add + local.set $end + local.get $address + local.set $i + loop $for-loop|0 + local.get $i + local.get $end + i32.lt_u + if + local.get $int + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/interpreter/Interpreter#get:memory + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $i + local.get $data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $i + local.get $address + i32.sub + call $~lib/typedarray/Uint8Array#__get + call $assembly/memory/Memory#setU8 + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/gas/GasCounterU64#set (param $this i32) (param $g i64) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $g + call $assembly/gas/GasCounterU64#set:gas + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/gas/GasCounterU64#sub (param $this i32) (param $g i64) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/gas/GasCounterU64#get:gas + local.get $g + i64.sub + call $assembly/gas/GasCounterU64#set:gas + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/gas/GasCounterU64#get:gas + i64.const 0 + i64.lt_s + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/gas/GasCounterU64#get (param $this i32) (result i64) + (local $1 i32) + (local $2 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/gas/GasCounterU64#get:gas + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#__visit" (param $this i32) (param $cookie i32) + (local $entries i32) + (local $cur i32) + (local $end i32) + (local $entry i32) + (local $val i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:buckets" + local.get $cookie + call $~lib/rt/itcms/__visit + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:entries" + local.set $entries + i32.const 1 + drop + local.get $entries + local.set $cur + local.get $cur + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.9" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.9" + end + i32.mul + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + drop + i32.const 1 + drop + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $val + i32.const 0 + drop + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + block $"~lib/map/ENTRY_SIZE|inlined.10" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.10" + end + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $entries + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28u8%29=>u8>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28u8%29=>u8>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/object/Object#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/rt/__newArray (param $length i32) (param $alignLog2 i32) (param $id i32) (param $data i32) (result i32) + (local $bufferSize i32) + (local $buffer i32) + (local $array i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + local.get $alignLog2 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + local.get $data + call $~lib/rt/__newBuffer + local.tee $buffer + i32.store + i32.const 16 + local.get $id + call $~lib/rt/itcms/__new + local.set $array + local.get $array + local.get $buffer + i32.store + local.get $array + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + local.get $array + local.get $buffer + i32.store offset=4 + local.get $array + local.get $bufferSize + i32.store offset=8 + local.get $array + local.get $length + i32.store offset=12 + local.get $array + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 0 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 0 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 23 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/arraybuffer/ArrayBuffer#constructor (param $this i32) (param $length i32) (result i32) + (local $buffer i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.gt_u + if + i32.const 8176 + i32.const 8224 + i32.const 52 + i32.const 43 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $buffer + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/util/number/utoa32 (param $value i32) (param $radix i32) (result i32) + (local $out i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|7 i32) + (local $buffer|8 i32) + (local $num|9 i32) + (local $offset|10 i32) + (local $decimals|11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 14608 + i32.const 14736 + i32.const 350 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i32.eqz + if + i32.const 14800 + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer + local.get $value + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 31 + local.get $value + i32.clz + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|7 + global.get $~lib/memory/__stack_pointer + local.get $decimals|7 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|8 + local.get $value + local.set $num|9 + local.get $decimals|7 + local.set $offset|10 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|8 + local.get $num|9 + i64.extend_i32_u + local.get $offset|10 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + i64.extend_i32_u + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|11 + global.get $~lib/memory/__stack_pointer + local.get $decimals|11 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $value + i64.extend_i32_u + local.get $decimals|11 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $out + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $~lib/util/number/itoa32 (param $value i32) (param $radix i32) (result i32) + (local $sign i32) + (local $out i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|8 i32) + (local $buffer|9 i32) + (local $num|10 i32) + (local $offset|11 i32) + (local $val32 i32) + (local $decimals|13 i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 14608 + i32.const 14736 + i32.const 373 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i32.eqz + if + i32.const 14800 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $value + i32.const 31 + i32.shr_u + i32.const 1 + i32.shl + local.set $sign + local.get $sign + if + i32.const 0 + local.get $value + i32.sub + local.set $value + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer + local.get $value + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 31 + local.get $value + i32.clz + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|8 + global.get $~lib/memory/__stack_pointer + local.get $decimals|8 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|9 + local.get $value + local.set $num|10 + local.get $decimals|8 + local.set $offset|11 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|9 + local.get $num|10 + i64.extend_i32_u + local.get $offset|11 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.set $val32 + local.get $val32 + i64.extend_i32_u + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|13 + global.get $~lib/memory/__stack_pointer + local.get $decimals|13 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.get $val32 + i64.extend_i32_u + local.get $decimals|13 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $sign + if + local.get $out + i32.const 45 + i32.store16 + end + local.get $out + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 2 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 32 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 3 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 3 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 14 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 2 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 35 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/util/number/utoa64 (param $value i64) (param $radix i32) (result i32) + (local $out i32) + (local $val32 i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|8 i32) + (local $buffer|9 i32) + (local $num|10 i64) + (local $offset|11 i32) + (local $decimals|12 i32) + (local $buffer|13 i32) + (local $num|14 i64) + (local $offset|15 i32) + (local $decimals|16 i32) + (local $17 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 14608 + i32.const 14736 + i32.const 401 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i64.const 0 + i64.ne + i32.eqz + if + i32.const 14800 + local.set $17 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $17 + return + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + call $~lib/util/number/decimalCount64High + local.set $decimals|8 + global.get $~lib/memory/__stack_pointer + local.get $decimals|8 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|9 + local.get $value + local.set $num|10 + local.get $decimals|8 + local.set $offset|11 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|9 + local.get $num|10 + local.get $offset|11 + call $~lib/util/number/utoa64_dec_lut + end + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 63 + local.get $value + i64.clz + i32.wrap_i64 + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|12 + global.get $~lib/memory/__stack_pointer + local.get $decimals|12 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|13 + local.get $value + local.set $num|14 + local.get $decimals|12 + local.set $offset|15 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|13 + local.get $num|14 + local.get $offset|15 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|16 + global.get $~lib/memory/__stack_pointer + local.get $decimals|16 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $value + local.get $decimals|16 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $out + local.set $17 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $17 + return + ) + (func $~lib/util/number/itoa64 (param $value i64) (param $radix i32) (result i32) + (local $sign i32) + (local $out i32) + (local $val32 i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|9 i32) + (local $buffer|10 i32) + (local $num|11 i64) + (local $offset|12 i32) + (local $decimals|13 i32) + (local $buffer|14 i32) + (local $num|15 i64) + (local $offset|16 i32) + (local $decimals|17 i32) + (local $18 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 14608 + i32.const 14736 + i32.const 431 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i64.const 0 + i64.ne + i32.eqz + if + i32.const 14800 + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + end + local.get $value + i64.const 63 + i64.shr_u + i32.wrap_i64 + i32.const 1 + i32.shl + local.set $sign + local.get $sign + if + i64.const 0 + local.get $value + i64.sub + local.set $value + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + call $~lib/util/number/decimalCount64High + local.set $decimals|9 + global.get $~lib/memory/__stack_pointer + local.get $decimals|9 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|10 + local.get $value + local.set $num|11 + local.get $decimals|9 + local.set $offset|12 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|10 + local.get $num|11 + local.get $offset|12 + call $~lib/util/number/utoa64_dec_lut + end + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 63 + local.get $value + i64.clz + i32.wrap_i64 + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|13 + global.get $~lib/memory/__stack_pointer + local.get $decimals|13 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|14 + local.get $value + local.set $num|15 + local.get $decimals|13 + local.set $offset|16 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|14 + local.get $num|15 + local.get $offset|16 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|17 + global.get $~lib/memory/__stack_pointer + local.get $decimals|17 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.get $value + local.get $decimals|17 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $sign + if + local.get $out + i32.const 45 + i32.store16 + end + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 0 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 0 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 58 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $export:assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $assembly/index/disassemble + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $export:assembly/index/runProgram (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + local.get $2 + call $assembly/index/runProgram + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $export:assembly/api-generic/runVm@varargs (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $assembly/api-generic/runVm@varargs + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $export:assembly/api-generic/getAssembly (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/api-generic/getAssembly + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/program-build/wrapAsProgram + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $export:assembly/api/resetGeneric (param $0 i32) (param $1 i32) (param $2 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + local.get $2 + call $assembly/api/resetGeneric + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $0 + local.get $1 + local.get $2 + local.get $3 + local.get $4 + call $assembly/api/resetGenericWithMemory + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api/setRegisters (param $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/api/setRegisters + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api/setMemory (param $0 i32) (param $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $0 + local.get $1 + call $assembly/api/setMemory + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) +) diff --git a/build/release.d.ts b/build/release.d.ts new file mode 100644 index 0000000..97c330c --- /dev/null +++ b/build/release.d.ts @@ -0,0 +1,182 @@ +/** Exported memory */ +export declare const memory: WebAssembly.Memory; +/** assembly/index/InputKind */ +export declare enum InputKind { + /** @type `i32` */ + Generic, + /** @type `i32` */ + SPI, +} +/** assembly/index/HasMetadata */ +export declare enum HasMetadata { + /** @type `i32` */ + Yes, + /** @type `i32` */ + No, +} +/** + * assembly/index/disassemble + * @param input `~lib/array/Array` + * @param kind `i32` + * @param withMetadata `i32` + * @returns `~lib/string/String` + */ +export declare function disassemble(input: Array, kind: number, withMetadata: number): string; +/** + * assembly/index/runProgram + * @param input `~lib/array/Array` + * @param registers `~lib/array/Array` + * @param kind `i32` + * @returns `assembly/api-generic/VmOutput` + */ +export declare function runProgram(input: Array, registers: Array, kind: number): __Record44; +/** + * assembly/api-generic/runVm + * @param input `assembly/api-generic/VmInput` + * @param logs `bool` + * @param useSbrkGas `bool` + * @returns `assembly/api-generic/VmOutput` + */ +export declare function runVm(input: __Record47, logs?: boolean, useSbrkGas?: boolean): __Record44; +/** + * assembly/api-generic/getAssembly + * @param p `assembly/program/Program` + * @returns `~lib/string/String` + */ +export declare function getAssembly(p: __Internref30): string; +/** + * assembly/program-build/wrapAsProgram + * @param bytecode `~lib/typedarray/Uint8Array` + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array; +/** + * assembly/api/resetGeneric + * @param program `~lib/array/Array` + * @param flatRegisters `~lib/array/Array` + * @param initialGas `i64` + */ +export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint): void; +/** + * assembly/api/resetGenericWithMemory + * @param program `~lib/array/Array` + * @param flatRegisters `~lib/array/Array` + * @param pageMap `~lib/typedarray/Uint8Array` + * @param chunks `~lib/typedarray/Uint8Array` + * @param initialGas `i64` + */ +export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint): void; +/** + * assembly/api/nextStep + * @returns `bool` + */ +export declare function nextStep(): boolean; +/** + * assembly/api/nSteps + * @param steps `u32` + * @returns `bool` + */ +export declare function nSteps(steps: number): boolean; +/** + * assembly/api/getProgramCounter + * @returns `u32` + */ +export declare function getProgramCounter(): number; +/** + * assembly/api/setNextProgramCounter + * @param pc `u32` + */ +export declare function setNextProgramCounter(pc: number): void; +/** + * assembly/api/getStatus + * @returns `u8` + */ +export declare function getStatus(): number; +/** + * assembly/api/getExitArg + * @returns `u32` + */ +export declare function getExitArg(): number; +/** + * assembly/api/getGasLeft + * @returns `i64` + */ +export declare function getGasLeft(): bigint; +/** + * assembly/api/setGasLeft + * @param gas `i64` + */ +export declare function setGasLeft(gas: bigint): void; +/** + * assembly/api/getRegisters + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function getRegisters(): Uint8Array; +/** + * assembly/api/setRegisters + * @param flatRegisters `~lib/array/Array` + */ +export declare function setRegisters(flatRegisters: Array): void; +/** + * assembly/api/getPageDump + * @param index `u32` + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function getPageDump(index: number): Uint8Array; +/** + * assembly/api/setMemory + * @param address `u32` + * @param data `~lib/typedarray/Uint8Array` + */ +export declare function setMemory(address: number, data: Uint8Array): void; +/** assembly/api-generic/InitialChunk */ +declare interface __Record45 { + /** @type `u32` */ + address: number | TOmittable; + /** @type `~lib/array/Array` */ + data: Array; +} +/** assembly/api-generic/VmOutput */ +declare interface __Record44 { + /** @type `i32` */ + status: number | TOmittable; + /** @type `~lib/array/Array` */ + registers: Array; + /** @type `u32` */ + pc: number | TOmittable; + /** @type `~lib/array/Array` */ + memory: Array<__Record45>; + /** @type `i64` */ + gas: bigint | TOmittable; + /** @type `u32` */ + exitCode: number | TOmittable; +} +/** assembly/api-generic/InitialPage */ +declare interface __Record48 { + /** @type `u32` */ + address: number | TOmittable; + /** @type `u32` */ + length: number | TOmittable; + /** @type `i32` */ + access: number | TOmittable; +} +/** assembly/api-generic/VmInput */ +declare interface __Record47 { + /** @type `~lib/array/Array` */ + registers: Array; + /** @type `u32` */ + pc: number | TOmittable; + /** @type `i64` */ + gas: bigint | TOmittable; + /** @type `~lib/array/Array` */ + program: Array; + /** @type `~lib/array/Array` */ + pageMap: Array<__Record48>; + /** @type `~lib/array/Array` */ + memory: Array<__Record45>; +} +/** assembly/program/Program */ +declare class __Internref30 extends Number { + private __nominal30: symbol; + private __nominal0: symbol; +} diff --git a/build/release.js b/build/release.js new file mode 100644 index 0000000..f4db6ff --- /dev/null +++ b/build/release.js @@ -0,0 +1,372 @@ +async function instantiate(module, imports = {}) { + const adaptedImports = { + env: Object.setPrototypeOf({ + abort(message, fileName, lineNumber, columnNumber) { + // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void + message = __liftString(message >>> 0); + fileName = __liftString(fileName >>> 0); + lineNumber = lineNumber >>> 0; + columnNumber = columnNumber >>> 0; + (() => { + // @external.js + throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); + })(); + }, + "console.log"(text) { + // ~lib/bindings/dom/console.log(~lib/string/String) => void + text = __liftString(text >>> 0); + console.log(text); + }, + }, Object.assign(Object.create(globalThis), imports.env || {})), + }; + const { exports } = await WebAssembly.instantiate(module, adaptedImports); + const memory = exports.memory || imports.env.memory; + const adaptedExports = Object.setPrototypeOf({ + InputKind: (values => ( + // assembly/index/InputKind + values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", + values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", + values + ))({}), + HasMetadata: (values => ( + // assembly/index/HasMetadata + values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", + values[values.No = exports["HasMetadata.No"].valueOf()] = "No", + values + ))({}), + disassemble(input, kind, withMetadata) { + // assembly/index/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String + input = __lowerArray(__setU8, 27, 0, input) || __notnull(); + return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); + }, + runProgram(input, registers, kind) { + // assembly/index/runProgram(~lib/array/Array, ~lib/array/Array, i32) => assembly/api-generic/VmOutput + input = __retain(__lowerArray(__setU8, 27, 0, input) || __notnull()); + registers = __lowerArray(__setU64, 43, 3, registers) || __notnull(); + try { + return __liftRecord44(exports.runProgram(input, registers, kind) >>> 0); + } finally { + __release(input); + } + }, + runVm(input, logs, useSbrkGas) { + // assembly/api-generic/runVm(assembly/api-generic/VmInput, bool?, bool?) => assembly/api-generic/VmOutput + input = __lowerRecord47(input) || __notnull(); + logs = logs ? 1 : 0; + useSbrkGas = useSbrkGas ? 1 : 0; + exports.__setArgumentsLength(arguments.length); + return __liftRecord44(exports.runVm(input, logs, useSbrkGas) >>> 0); + }, + getAssembly(p) { + // assembly/api-generic/getAssembly(assembly/program/Program) => ~lib/string/String + p = __lowerInternref(p) || __notnull(); + return __liftString(exports.getAssembly(p) >>> 0); + }, + wrapAsProgram(bytecode) { + // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array + bytecode = __lowerTypedArray(Uint8Array, 5, 0, bytecode) || __notnull(); + return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0); + }, + resetGeneric(program, flatRegisters, initialGas) { + // assembly/api/resetGeneric(~lib/array/Array, ~lib/array/Array, i64) => void + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); + initialGas = initialGas || 0n; + try { + exports.resetGeneric(program, flatRegisters, initialGas); + } finally { + __release(program); + } + }, + resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas) { + // assembly/api/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64) => void + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + flatRegisters = __retain(__lowerArray(__setU8, 27, 0, flatRegisters) || __notnull()); + pageMap = __retain(__lowerTypedArray(Uint8Array, 5, 0, pageMap) || __notnull()); + chunks = __lowerTypedArray(Uint8Array, 5, 0, chunks) || __notnull(); + initialGas = initialGas || 0n; + try { + exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas); + } finally { + __release(program); + __release(flatRegisters); + __release(pageMap); + } + }, + nextStep() { + // assembly/api/nextStep() => bool + return exports.nextStep() != 0; + }, + nSteps(steps) { + // assembly/api/nSteps(u32) => bool + return exports.nSteps(steps) != 0; + }, + getProgramCounter() { + // assembly/api/getProgramCounter() => u32 + return exports.getProgramCounter() >>> 0; + }, + getExitArg() { + // assembly/api/getExitArg() => u32 + return exports.getExitArg() >>> 0; + }, + setGasLeft(gas) { + // assembly/api/setGasLeft(i64) => void + gas = gas || 0n; + exports.setGasLeft(gas); + }, + getRegisters() { + // assembly/api/getRegisters() => ~lib/typedarray/Uint8Array + return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); + }, + setRegisters(flatRegisters) { + // assembly/api/setRegisters(~lib/array/Array) => void + flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); + exports.setRegisters(flatRegisters); + }, + getPageDump(index) { + // assembly/api/getPageDump(u32) => ~lib/typedarray/Uint8Array + return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); + }, + setMemory(address, data) { + // assembly/api/setMemory(u32, ~lib/typedarray/Uint8Array) => void + data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); + exports.setMemory(address, data); + }, + }, exports); + function __liftRecord45(pointer) { + // assembly/api-generic/InitialChunk + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + address: __getU32(pointer + 0), + data: __liftArray(__getU8, 0, __getU32(pointer + 4)), + }; + } + function __liftRecord44(pointer) { + // assembly/api-generic/VmOutput + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + status: __getI32(pointer + 0), + registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), + pc: __getU32(pointer + 8), + memory: __liftArray(pointer => __liftRecord45(__getU32(pointer)), 2, __getU32(pointer + 12)), + gas: __getI64(pointer + 16), + exitCode: __getU32(pointer + 24), + }; + } + function __lowerRecord48(value) { + // assembly/api-generic/InitialPage + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(12, 48)); + __setU32(pointer + 0, value.address); + __setU32(pointer + 4, value.length); + __setU32(pointer + 8, value.access); + exports.__unpin(pointer); + return pointer; + } + function __lowerRecord45(value) { + // assembly/api-generic/InitialChunk + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(8, 45)); + __setU32(pointer + 0, value.address); + __setU32(pointer + 4, __lowerArray(__setU8, 27, 0, value.data) || __notnull()); + exports.__unpin(pointer); + return pointer; + } + function __lowerRecord47(value) { + // assembly/api-generic/VmInput + // Hint: Opt-out from lowering as a record by providing an empty constructor + if (value == null) return 0; + const pointer = exports.__pin(exports.__new(28, 47)); + __setU32(pointer + 0, __lowerArray(__setU64, 43, 3, value.registers) || __notnull()); + __setU32(pointer + 4, value.pc); + __setU64(pointer + 8, value.gas || 0n); + __setU32(pointer + 16, __lowerArray(__setU8, 27, 0, value.program) || __notnull()); + __setU32(pointer + 20, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, value.pageMap) || __notnull()); + __setU32(pointer + 24, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord45(value) || __notnull()); }, 46, 2, value.memory) || __notnull()); + exports.__unpin(pointer); + return pointer; + } + function __liftString(pointer) { + if (!pointer) return null; + const + end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, + memoryU16 = new Uint16Array(memory.buffer); + let + start = pointer >>> 1, + string = ""; + while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); + return string + String.fromCharCode(...memoryU16.subarray(start, end)); + } + function __liftArray(liftElement, align, pointer) { + if (!pointer) return null; + const + dataStart = __getU32(pointer + 4), + length = __dataview.getUint32(pointer + 12, true), + values = new Array(length); + for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0)); + return values; + } + function __lowerArray(lowerElement, id, align, values) { + if (values == null) return 0; + const + length = values.length, + buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, + header = exports.__pin(exports.__new(16, id)) >>> 0; + __setU32(header + 0, buffer); + __dataview.setUint32(header + 4, buffer, true); + __dataview.setUint32(header + 8, length << align, true); + __dataview.setUint32(header + 12, length, true); + for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]); + exports.__unpin(buffer); + exports.__unpin(header); + return header; + } + function __liftTypedArray(constructor, pointer) { + if (!pointer) return null; + return new constructor( + memory.buffer, + __getU32(pointer + 4), + __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT + ).slice(); + } + function __lowerTypedArray(constructor, id, align, values) { + if (values == null) return 0; + const + length = values.length, + buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, + header = exports.__new(12, id) >>> 0; + __setU32(header + 0, buffer); + __dataview.setUint32(header + 4, buffer, true); + __dataview.setUint32(header + 8, length << align, true); + new constructor(memory.buffer, buffer, length).set(values); + exports.__unpin(buffer); + return header; + } + class Internref extends Number {} + function __lowerInternref(value) { + if (value == null) return 0; + if (value instanceof Internref) return value.valueOf(); + throw TypeError("internref expected"); + } + const refcounts = new Map(); + function __retain(pointer) { + if (pointer) { + const refcount = refcounts.get(pointer); + if (refcount) refcounts.set(pointer, refcount + 1); + else refcounts.set(exports.__pin(pointer), 1); + } + return pointer; + } + function __release(pointer) { + if (pointer) { + const refcount = refcounts.get(pointer); + if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer); + else if (refcount) refcounts.set(pointer, refcount - 1); + else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`); + } + } + function __notnull() { + throw TypeError("value must not be null"); + } + let __dataview = new DataView(memory.buffer); + function __setU8(pointer, value) { + try { + __dataview.setUint8(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setUint8(pointer, value, true); + } + } + function __setU32(pointer, value) { + try { + __dataview.setUint32(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setUint32(pointer, value, true); + } + } + function __setU64(pointer, value) { + try { + __dataview.setBigUint64(pointer, value, true); + } catch { + __dataview = new DataView(memory.buffer); + __dataview.setBigUint64(pointer, value, true); + } + } + function __getU8(pointer) { + try { + return __dataview.getUint8(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getUint8(pointer, true); + } + } + function __getI32(pointer) { + try { + return __dataview.getInt32(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getInt32(pointer, true); + } + } + function __getU32(pointer) { + try { + return __dataview.getUint32(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getUint32(pointer, true); + } + } + function __getI64(pointer) { + try { + return __dataview.getBigInt64(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getBigInt64(pointer, true); + } + } + function __getU64(pointer) { + try { + return __dataview.getBigUint64(pointer, true); + } catch { + __dataview = new DataView(memory.buffer); + return __dataview.getBigUint64(pointer, true); + } + } + return adaptedExports; +} +export const { + memory, + InputKind, + HasMetadata, + disassemble, + runProgram, + runVm, + getAssembly, + wrapAsProgram, + resetGeneric, + resetGenericWithMemory, + nextStep, + nSteps, + getProgramCounter, + setNextProgramCounter, + getStatus, + getExitArg, + getGasLeft, + setGasLeft, + getRegisters, + setRegisters, + getPageDump, + setMemory, +} = await (async url => instantiate( + await (async () => { + const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); + if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } + else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } + })(), { + } +))(new URL("release.wasm", import.meta.url)); diff --git a/build/release.wasm b/build/release.wasm new file mode 100644 index 0000000000000000000000000000000000000000..5dbaeb3b3175e196f275a6e9299e4947e9fcf099 GIT binary patch literal 93361 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 I=Ge^t0d}!nbN~PV literal 0 HcmV?d00001 diff --git a/build/release.wasm.map b/build/release.wasm.map new file mode 100644 index 0000000..16de3d7 --- /dev/null +++ b/build/release.wasm.map @@ -0,0 +1 @@ +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/api.ts","assembly/index.ts","~lib/number.ts","~lib/string.ts","~lib/memory.ts","assembly/api-generic.ts","assembly/gas.ts","assembly/program-build.ts","~lib/dataview.ts","~lib/function.ts"],"names":[],"mappings":"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zCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAGA,EAAO,E,EACY,E,GAAjB,EACmB,EAAb,CAAF,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D,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTwHO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDShIM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/EgB,CAAlD,EAAK,EAAL,EU+EoB,EAAzB,G,EAE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CAAlD,EAAK,EAAL,EUkJ0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZjLO,E,6Da9CP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KX6EJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EW7EI,G,EX6EkB,CAAlD,EAAK,EAAL,EW7EkB,EAAzB,Eb8CO,E,sDaxCH,E,KAAc,E,KXuEiB,E,EWvEjB,G,EXuEuC,CAAlD,EAAK,EAAL,EWvEH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EXiE1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GWjEb,GbuCK,E,sDahCH,E,KAAc,E,KX+DiB,E,EW/DjB,G,EX+DuC,CAAlD,EAAK,EAAL,EW/DH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EXyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GWzDb,Gb+BK,E,6DaxBH,E,KAAc,E,KXuDiB,E,EWvDjB,G,EXuDuC,CAAlD,EAAK,EAAL,EWvDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KXsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EWtDM,G,EXsDgB,CAAlD,EAAK,EAAL,EWtDoB,EAAzB,GbuBK,E,6DahBH,E,KAAc,E,KX+CiB,E,EW/CjB,G,EX+CuC,CAAlD,EAAK,EAAL,EW/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KX8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EW9CM,G,EX8CgB,CAAlD,EAAK,EAAL,EW9CoB,EAAzB,GbeK,E,6Dc9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZ6EL,E,EY7EK,G,EZ6EiB,CAAlD,EAAK,EAAL,EY7EwB,E,IAAiC,EZwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EY7EwB,E,EZwEhB,GYvBN,CAjDT,Ed8CO,E,6DcxCP,E,YAAS,G,IAAoC,E,KZkE9B,G,IYlEuC,E,KAAS,E,KZuE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EYvE4B,G,EZuEN,CAAlD,EAAK,EAAL,EYvE+C,EA2C7C,CA3CT,EdwCO,E,6DclCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZiE1B,E,EYjE0B,G,EZiEJ,CAAlD,EAAK,EAAL,E,EYjEyC,C,IAA4B,EAyCtD,G,EZwBa,E,EAAsB,CAAlD,EAAK,EAAL,EYjEyC,E,EAyC1B,GAAb,CZmBF,CY5DP,EdkCO,E,6Dc5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,KZ2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EYxBY,E,EZwBgB,E,EY3DuC,G,EZ2DjB,CAAlD,EAAK,EAAL,E,EY3DsD,CAmCpD,CZmBF,CYtDP,Ed4BO,E,6DctBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZqDL,E,EYrDK,G,EZqDiB,CAAlD,EAAK,EAAL,EYrDwB,E,IAAmB,E,KAAS,E,KZqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EYrDwB,E,EZqDI,E,EYrDwB,G,EZqDF,CAAlD,EAAK,EAAL,EYrD2C,EAiCzC,CAjCT,EdsBO,E,6DchBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZ+C1B,E,EY/C0B,G,EZ+CJ,CAAlD,EAAK,EAAL,E,EY/CyC,C,IAA4B,E,KAAS,E,KZ+ClD,E,EAAsB,CAAlD,EAAK,EAAL,EY/CyC,E,EZ+Cb,E,EY/CkD,G,EZ+C5B,CAAlD,EAAK,EAAL,E,EY/CiE,CA+B/D,CZWF,CY1CP,EdgBO,E,6DcVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZyCL,E,EYzCK,G,EZyCiB,CAAlD,EAAK,EAAL,EYzCwB,E,IAAmB,E,KAAS,E,KZyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EYzCwB,E,EZyCI,E,EYzCwB,G,EZyCF,CAAlD,EAAK,EAAL,EYzC2C,EAazC,CAbT,EdUO,E,6DcJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZmC1B,E,EYnC0B,G,EZmCJ,CAAlD,EAAK,EAAL,E,EYnCyC,C,IAA4B,E,KAAS,E,KZmClD,E,EAAsB,CAAlD,EAAK,EAAL,EYnCyC,E,EZmCb,E,EYnCkD,G,EZmC5B,CAAlD,EAAK,EAAL,E,EYnCiE,CAW/D,CZmBF,CY9BP,EdIO,E,sDe9CM,E,Yb6EsB,E,Ea7ER,G,Eb6E8B,CAAlD,EAAK,EAAL,Ea7EM,E,EAA2C,EbwEzC,G,EAAA,GaxEF,CAAb,E,EACA,E,KAAc,E,Kb4EqB,E,Ea5ErB,G,Eb4E2C,CAAlD,EAAK,EAAL,Ea5EkB,GAAzB,Ef6CO,E,sDevCU,E,YbsEkB,E,EatEJ,G,EbsE0B,CAAlD,EAAK,EAAL,EatEM,E,EAA4C,EbiE1C,G,EAAA,GajEF,CAAb,E,EACA,E,KAAc,E,KbqEqB,E,EarErB,G,EbqE2C,CAAlD,EAAK,EAAL,EarEkB,GAAzB,EfsCO,E,sDehCM,E,Yb+DsB,E,Ea/DR,G,Eb+D8B,CAAlD,EAAK,EAAL,Ea/DM,E,EAA2C,Eb0DzC,G,EAAA,Ga1DF,CAAb,E,EACA,E,KAAc,E,Kb8DqB,E,Ea9DrB,G,Eb8D2C,CAAlD,EAAK,EAAL,Ea9DkB,GAAzB,Ef+BO,E,sDezBU,E,YbwDkB,E,EaxDJ,G,EbwD0B,CAAlD,EAAK,EAAL,EaxDM,E,EAA4C,EbmD1C,G,EAAA,GanDF,CAAb,E,EACA,E,KAAc,E,KbuDqB,E,EavDrB,G,EbuD2C,CAAlD,EAAK,EAAL,EavDkB,GAAzB,EfwBO,E,6DelBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbiDJ,E,EajDI,G,EbiDkB,CAAlD,EAAK,EAAL,EajDkB,E,IAAyB,E,KAAc,E,KbiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EajD6B,G,EbiDP,CAAlD,EAAK,EAAL,EajD2C,EAAzB,IAAzB,EfkBO,E,6DeZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kb2CR,E,Ea3CQ,G,Eb2Cc,CAAlD,EAAK,EAAL,Ea3CkB,E,IAAkC,E,KAAc,E,Kb2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea3CsC,G,Eb2ChB,CAAlD,EAAK,EAAL,Ea3CgD,EAA9B,IAAzB,EfYO,E,wDgB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdyEG,E,EczEH,G,EdyEyB,CAAlD,EAAK,EAAL,E,EczEO,CAAd,E,EACA,E,KAAc,E,KdwEqB,E,EcxErB,G,EdwE2C,CAAlD,EAAK,EAAL,EcxEgC,EAAS,EAAT,CdmEhC,CcnEP,EhByCO,E,wDgBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdiEG,E,EcjEH,G,EdiEyB,CAAlD,EAAK,EAAL,E,EcjEO,CAAd,E,EACA,E,KAAc,E,KdgEqB,E,EchErB,G,EdgE2C,CAAlD,EAAK,EAAL,EchEgC,EAAU,EAAV,Cd2DhC,Cc3DP,EhBiCO,E,sDgB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KdyDX,E,EczDW,G,EdyDW,CAAlD,EAAK,EAAL,E,EczDqB,CAA5B,E,EACA,E,KAAc,E,KdwDqB,E,EcxDrB,G,EdwD2C,CAAlD,EAAK,EAAL,EcxDkB,E,EAAS,CAAT,CAAzB,EhByBO,E,sDgBnBW,E,KAAc,E,KdkDG,E,EclDH,G,EdkDyB,CAAlD,EAAK,EAAL,EclDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EdiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KcjD0C,EAAV,Cd4ChC,Cc5CP,EhBkBO,E,sDgBZW,E,KAAc,E,Kd2CG,E,Ec3CH,G,Ed2CyB,CAAlD,EAAK,EAAL,Ec3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,Ed0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,Kc1C2C,EAAX,CdqChC,CcrCP,EhBWO,E,sDgBLW,E,YdoCiB,E,EcpCH,G,EdoCyB,CAAlD,EAAK,EAAL,EcpCW,E,GAAJ,CAAd,E,EAC0B,E,Kd8BX,Gc9Bf,E,EACA,E,KAAc,E,KdkCqB,E,EclCrB,G,EdkC2C,CAAlD,EAAK,EAAL,EclCoC,E,EAAO,C,CAAX,CAAvC,EhBGO,E,6DgBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kd2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ec3BI,G,Ed2BkB,CAAlD,EAAK,EAAL,Ec3BkB,E,EAA0B,CAA1B,CAAzB,EhBJO,E,6DgBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcpBI,G,EdoBkB,CAAlD,EAAK,EAAL,EcpBkB,E,EAA2B,CAA3B,CAAzB,EhBXO,E,sDgBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdaG,E,EcbH,G,EdayB,CAAlD,EAAK,EAAL,EcbO,EAAd,E,EACA,E,KAAc,E,KdYqB,E,EcZrB,G,EdY2C,CAAlD,EAAK,EAAL,EcZkB,E,EAAS,CAAT,CAAzB,EhBnBO,E,sDgByBW,E,KAAc,E,KdMG,E,EcNH,G,EdMyB,CAAlD,EAAK,EAAL,EcNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EdAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EcAmC,CAAzB,CAAzB,EhB1BO,E,sDgBgCW,E,KAAc,E,KdDG,E,EcCH,G,EdDyB,CAAlD,EAAK,EAAL,EcCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EdPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EcOoC,CAA1B,CAAzB,EhBjCO,E,sDgBuCW,E,YdRiB,E,EcQH,G,EdRyB,CAAlD,EAAK,EAAL,EcQW,E,GAAJ,CAAd,E,EAC4B,E,Kddb,Gccf,E,EACA,E,KAAc,E,KdVqB,E,EcUrB,G,EdV2C,CAAlD,EAAK,EAAL,EcUoC,E,EAAS,C,CAAb,CAAvC,EhBzCO,E,wDgB+CW,E,KAAc,E,KdhBG,E,EcgBH,G,EdhByB,CAAlD,EAAK,EAAL,EcgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KdjBG,E,EciBH,G,EdjByB,CAAlD,EAAK,EAAL,E,EciBO,CAAd,E,EACA,E,KAAc,E,KdlBqB,E,EckBrB,G,EdlB2C,CAAlD,EAAK,EAAL,EckBgC,EAAS,EAAT,CdvBhC,CcuBP,EhBjDO,E,wDgBuDW,E,KAAc,E,KdxBG,E,EcwBH,G,EdxByB,CAAlD,EAAK,EAAL,EcwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KdzBG,E,EcyBH,G,EdzByB,CAAlD,EAAK,EAAL,E,EcyBO,CAAd,E,EACA,E,KAAc,E,Kd1BqB,E,Ec0BrB,G,Ed1B2C,CAAlD,EAAK,EAAL,Ec0BgC,EAAU,EAAV,Cd/BhC,Cc+BP,EhBzDO,E,sDgB+DW,E,KAAc,E,KdhCG,E,EcgCH,G,EdhCyB,CAAlD,EAAK,EAAL,EcgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KdjCd,E,EciCc,G,EdjCQ,CAAlD,EAAK,EAAL,E,EciCwB,CAA/B,E,EACA,E,KAAc,E,KdlCqB,E,EckCrB,G,EdlC2C,CAAlD,EAAK,EAAL,EckCoC,E,EAAY,C,CAAhB,CAAvC,EhBjEO,E,6DgBuEW,E,KAAc,E,KdxCG,E,EcwCH,G,EdxCyB,CAAlD,EAAK,EAAL,EcwCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdzCJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcyCI,G,EdzCkB,CAAlD,EAAK,EAAL,EcyCkB,E,EAA0B,CAA1B,CAAzB,EhBxEO,E,6DgB8EW,E,KAAc,E,Kd/CG,E,Ec+CH,G,Ed/CyB,CAAlD,EAAK,EAAL,Ec+CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdhDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcgDI,G,EdhDkB,CAAlD,EAAK,EAAL,EcgDkB,E,EAA2B,CAA3B,CAAzB,EhB/EO,E,6DgBqFW,E,KAAc,E,KdtDG,E,EcsDH,G,EdtDyB,CAAlD,EAAK,EAAL,EcsDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,KdvDR,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcuDQ,G,EdvDc,CAAlD,EAAK,EAAL,EcuDkB,E,EAA+B,CAA/B,CAAzB,EhBtFO,E,mDV8HkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cACnD,E,GAAiB,E,KAAjB,CAA+B,EAAzC,G,2DQ6DY,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,E,IAAf,G,EACO,E,kEmB/OO,E,QAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,2DnBiPO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,EAAQ,GAAR,CAAf,G,EACI,E,iBAAA,EAAmB,EAAnB,CAAJ,E,EACE,E,iBAAU,EAAK,E,KAAS,EAAT,CAAf,I,EAEA,E,iBAAW,EAAK,E,KAAS,EAAT,CAAhB,I,EAEK,E,kEmBtPO,E,QAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DnBwPO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,EAAK,EAAI,GAAJ,CAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,EAAK,EAAI,GAAJ,CAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEmBrQO,E,QAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DnBuQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,E,EAAK,C,IAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,E,EAAK,C,IAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEmBpRO,E,QAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EfkDjB,GelDG,G,OACD,E,KAAV,E,+DAKO,E,KAAa,E,YAAa,E,KAAc,E,WfiDnB,E,EejDmB,G,EfiDG,CAAlD,EAAK,EAAL,EejDiC,EAAyB,G,CAA9B,CAArB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAc,E,KAAc,E,Wf2CrB,E,Ee3CqB,G,Ef2CC,CAAlD,EAAK,EAAL,Ee3CmC,EAAyB,I,CAA/B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAY,E,KAAc,E,WfqCnB,E,EerCmB,G,EfqCG,CAAlD,EAAK,EAAL,E,EerC6B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAQ,E,KAAc,E,Wf+Bf,E,Ee/Be,G,Ef+BO,CAAlD,EAAK,EAAL,Ee/B6B,EAAtB,G,OACG,E,KAAV,E,6DAKa,E,YfyBe,E,EezBD,G,EfyBuB,CAAlD,EAAK,EAAL,EezBa,E,EAAuC,EfoB5C,G,EAAA,G,CepBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YfkBe,E,EelBD,G,EfkBuB,CAAlD,EAAK,EAAL,EelBa,E,EAAuC,Efa5C,G,EAAA,G,CebC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YfWe,E,EeXD,G,EfWuB,CAAlD,EAAK,EAAL,EeXa,E,EAAuC,EfM5C,G,EAAA,G,CeNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YfIe,E,EeJD,G,EfIuB,CAAlD,EAAK,EAAL,EeJa,E,EAAuC,EfD5C,G,EAAA,G,CeCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EfFjB,GeEG,G,OACD,E,KAAV,E,+DAKa,E,YfHe,E,EeGD,G,EfHuB,CAAlD,EAAK,EAAL,EeGa,E,EAAuC,EfR5C,G,EAAA,G,CeQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EfJQ,E,EeIoB,G,EfJE,CAAlD,EAAK,EAAL,EeIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YfVe,E,EeUD,G,EfVuB,CAAlD,EAAK,EAAL,EeUa,E,EAAuC,Eff5C,G,EAAA,G,CeeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EfXO,E,EeWsB,G,EfXA,CAAlD,EAAK,EAAL,EeWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YfjBe,E,EeiBD,G,EfjBuB,CAAlD,EAAK,EAAL,EeiBa,E,EAAuC,EftB5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OACK,E,QAAf,E,EACgB,EAAI,EAAJ,C,EACU,EAA2B,EAAY,EAAZ,CAA3B,CAAR,G,IAAkE,E,SAAlE,EAA+D,E,EAAlE,E,GAAA,G,KACJ,EAAY,EAAY,EAAZ,CAAZ,CAAuC,EAAhD,GAES,EAAwB,EAA2B,EADxC,EAHK,E,GAAF,E,WAOlB,E,8CRsHG,E,KAOmC,G,EANnC,EAMwC,G,EAAA,G,aAArB,G,wD2B7JI,E,KAAN,E,EAAY,EAA5B,G,KACT,GAAJ,E,OACS,EAAP,E,yEAfO,E,YACA,E,YACA,E,YACA,E,UACO,E,sCAehB,E,KAAmB,E,gCAEX,E,mBAOJ,E,KAA2B,E,OpB3NhB,G,QoBkOX,E,KAAa,E,KAAc,E,OpB7NI,E,EoB6NJ,G,EpB7N0B,CAAlD,EAAK,EAAL,EoB6NU,E,QAIb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,KACb,E,KAAkB,E,KAAJ,GAAe,EAAf,C,IAAyB,EAAJ,G,EAArB,E,EAAqB,GAAtB,C,QAab,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAAa,E,KAAc,E,OpBhPI,E,EoBgPJ,G,EpBhP0B,CAAlD,EAAK,EAAL,EoBgPU,E,QAab,E,KAAa,E,KAAc,E,OpB7PI,E,EoB6PJ,G,EpB7P0B,CAAlD,EAAK,EAAL,EoB6PU,E,KACb,E,KAAa,E,KAAc,E,OpB9PI,E,EoB8PJ,G,EpB9P0B,CAAlD,EAAK,EAAL,EoB8PU,E,KACb,E,KAA2B,E,OpBpQhB,G,KoBqQX,E,KAA2B,E,OpBrQhB,G,QoBwQX,E,KAAa,E,KAAc,E,OpBnQI,E,EoBmQJ,G,EpBnQ0B,CAAlD,EAAK,EAAL,EoBmQU,E,KACb,E,KAAa,E,KAAc,E,OpBpQI,E,EoBoQJ,G,EpBpQ0B,CAAlD,EAAK,EAAL,EoBoQU,E,KACb,E,KAAa,E,KAAc,E,OpBrQI,E,EoBqQJ,G,EpBrQ0B,CAAlD,EAAK,EAAL,EoBqQU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBxNhB,G,QoB4NX,E,KAA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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/0a78010a7801?v=0.6.4 **/\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT = 12;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/24ee0024ee00?v=0.6.4 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const pageIdx = u32(currentAddress >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n const relAddress = currentAddress % PAGE_SIZE;\n const page = this.pages.get(pageIdx);\n const spaceInPage = PAGE_SIZE - relAddress;\n\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** https://graypaper.fluffylabs.dev/#/9a08063/2cc5022cc502?v=0.6.6 */\nexport function decodeSpi(data: Uint8Array): Program {\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const _heapPages = decoder.u16();\n const _stackSize = decoder.u24();\n\n const _roMem = decoder.bytes(roLength);\n const _rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n return deblob(code);\n}\n\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { RUN } from \"./instructions-exe\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, JumpTable, Program, ProgramCounter, decodeArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { InitialChunk, InitialPage, buildMemory } from \"./api-generic\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { VmInput, VmOutput, getAssembly, runVm } from \"./api-generic\";\nimport { deblob, decodeSpi, extractCodeAndMetadata, liftBytes } from \"./program\";\n\nexport * from \"./api\";\nexport { runVm, getAssembly } from \"./api-generic\";\nexport { wrapAsProgram } from \"./program-build\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n let program = liftBytes(input);\n let output = \"\";\n\n if (withMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(program);\n program = data.code;\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += data.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n if (kind === InputKind.Generic) {\n const p = deblob(program);\n return output + getAssembly(p);\n }\n\n if (kind === InputKind.SPI) {\n const p = decodeSpi(program);\n return output + getAssembly(p);\n }\n\n return `Unknown kind: ${kind}`;\n}\n\nexport function runProgram(input: u8[], registers: u64[], kind: InputKind): VmOutput {\n if (kind === InputKind.Generic) {\n const vmInput = new VmInput();\n vmInput.registers = registers;\n vmInput.gas = 10_000;\n vmInput.program = input;\n\n const output = runVm(vmInput, true);\n console.log(`Finished with status: ${output.status}`);\n return output;\n }\n\n if (kind === InputKind.SPI) {\n throw new Error(\"SPI running not supported yet\");\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { Program, deblob, decodeArguments, liftBytes, resolveArguments } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n registers: u64[] = new Array(NO_OF_REGISTERS).fill(0);\n pc: u32 = 0;\n gas: i64 = 0;\n program: u8[] = [];\n pageMap: InitialPage[] = [];\n memory: InitialChunk[] = [];\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const p = deblob(liftBytes(input.program));\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < registers.length; r++) {\n registers[r] = input.registers[r];\n }\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, input.pageMap, input.memory);\n\n const int = new Interpreter(p, registers, memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = p.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n return this.gas < 0;\n }\n}\n","import { Arguments, REQUIRED_BYTES, nibbles } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/release.wat b/build/release.wat new file mode 100644 index 0000000..4de45a6 --- /dev/null +++ b/build/release.wat @@ -0,0 +1,36780 @@ +(module + (type $0 (func (param i32 i32 i32) (result i32))) + (type $1 (func (param i32 i32) (result i32))) + (type $2 (func (param i32) (result i32))) + (type $3 (func (result i32))) + (type $4 (func (param i32))) + (type $5 (func (param i32 i32))) + (type $6 (func (param i32 i32 i32))) + (type $7 (func (param i32 i32 i32 i32) (result i32))) + (type $8 (func)) + (type $9 (func (param i32 i32 i32 i32))) + (type $10 (func (param i32 i32 i64))) + (type $11 (func (param i32 i64) (result i32))) + (type $12 (func (param i64 i32 i32) (result i32))) + (type $13 (func (param i64) (result i32))) + (type $14 (func (param i32 i32 i32 i32 i64))) + (type $15 (func (param i32 i64 i32 i32))) + (type $16 (func (param i32 i64 i32))) + (type $17 (func (param i32 i64))) + (type $18 (func (param i32) (result i64))) + (type $19 (func (param i32 i32) (result i64))) + (type $20 (func (param i32 i32 i64) (result i32))) + (type $21 (func (result i64))) + (type $22 (func (param i64))) + (type $23 (func (param i64 i32) (result i32))) + (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) + (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) + (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) + (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) + (global $~argumentsLength (mut i32) (i32.const 0)) + (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) + (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) + (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) + (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) + (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) + (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) + (global $assembly/api/interpreter (mut i32) (i32.const 0)) + (global $assembly/index/InputKind.Generic i32 (i32.const 0)) + (global $assembly/index/InputKind.SPI i32 (i32.const 1)) + (global $assembly/index/HasMetadata.Yes i32 (i32.const 0)) + (global $assembly/index/HasMetadata.No i32 (i32.const 1)) + (global $~lib/rt/__rtti_base i32 (i32.const 21056)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 54068)) + (memory $0 1) + (data $0 (i32.const 1036) "L") + (data $0.1 (i32.const 1048) "\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03") + (data $1 (i32.const 1116) ",") + (data $1.1 (i32.const 1128) "\04\00\00\00\10\00\00\00 \04\00\00 \04\00\004\00\00\00\r") + (data $2 (i32.const 1164) "L") + (data $2.1 (i32.const 1176) "\01\00\00\004") + (data $2.2 (i32.const 1192) "\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02") + (data $3 (i32.const 1244) ",") + (data $3.1 (i32.const 1256) "\04\00\00\00\10\00\00\00\a0\04\00\00\a0\04\00\004\00\00\00\r") + (data $4 (i32.const 1292) "<") + (data $4.1 (i32.const 1304) "\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e") + (data $5 (i32.const 1356) "<") + (data $5.1 (i32.const 1368) "\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s") + (data $8 (i32.const 1484) "<") + (data $8.1 (i32.const 1496) "\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e") + (data $9 (i32.const 1548) ",") + (data $9.1 (i32.const 1560) "\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s") + (data $11 (i32.const 1628) "<") + (data $11.1 (i32.const 1640) "\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s") + (data $12 (i32.const 1692) "\1c") + (data $12.1 (i32.const 1704) "\08\00\00\00\08\00\00\00\01") + (data $13 (i32.const 1724) "<") + (data $13.1 (i32.const 1736) "\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s") + (data $14 (i32.const 1788) "\1c") + (data $14.1 (i32.const 1800) "\08\00\00\00\08\00\00\00\02") + (data $15 (i32.const 1820) "\1c") + (data $15.1 (i32.const 1832) "\08\00\00\00\08\00\00\00\03") + (data $16 (i32.const 1852) "\1c") + (data $16.1 (i32.const 1864) "\08\00\00\00\08\00\00\00\04") + (data $17 (i32.const 1884) "\1c") + (data $17.1 (i32.const 1896) "\08\00\00\00\08\00\00\00\05") + (data $18 (i32.const 1916) "\1c") + (data $18.1 (i32.const 1928) "\08\00\00\00\08\00\00\00\06") + (data $19 (i32.const 1948) "\1c") + (data $19.1 (i32.const 1960) "\08\00\00\00\08\00\00\00\07") + (data $20 (i32.const 1980) "\1c") + (data $20.1 (i32.const 1992) "\08\00\00\00\08\00\00\00\08") + (data $21 (i32.const 2012) "\1c") + (data $21.1 (i32.const 2024) "\08\00\00\00\08\00\00\00\t") + (data $22 (i32.const 2044) "\1c") + (data $22.1 (i32.const 2056) "\08\00\00\00\08\00\00\00\n") + (data $23 (i32.const 2076) "\1c") + (data $23.1 (i32.const 2088) "\08\00\00\00\08\00\00\00\0b") + (data $24 (i32.const 2108) "\1c") + (data $24.1 (i32.const 2120) "\08\00\00\00\08\00\00\00\0c") + (data $25 (i32.const 2140) "\1c") + (data $25.1 (i32.const 2152) "\08\00\00\00\08\00\00\00\r") + (data $26 (i32.const 2172) "L") + (data $26.1 (i32.const 2184) "\01\00\00\004\00\00\00\b0\06\00\00\10\07\00\000\07\00\00P\07\00\00p\07\00\00\90\07\00\00\b0\07\00\00\d0\07\00\00\f0\07\00\00\10\08\00\000\08\00\00P\08\00\00p\08") + (data $27 (i32.const 2252) ",") + (data $27.1 (i32.const 2264) "\07\00\00\00\10\00\00\00\90\08\00\00\90\08\00\004\00\00\00\r") + (data $28 (i32.const 2300) ",") + (data $28.1 (i32.const 2312) "\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D") + (data $29 (i32.const 2348) "\1c") + (data $29.1 (i32.const 2360) "\02\00\00\00\08\00\00\00S\00B\00R\00K") + (data $30 (i32.const 2380) "\1c") + (data $30.1 (i32.const 2392) "\02\00\00\00\08\00\00\00T\00R\00A\00P") + (data $31 (i32.const 2412) ",") + (data $31.1 (i32.const 2424) "\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H") + (data $32 (i32.const 2460) "\1c") + (data $32.1 (i32.const 2472) "\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I") + (data $33 (i32.const 2492) ",") + (data $33.1 (i32.const 2504) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004") + (data $34 (i32.const 2540) ",") + (data $34.1 (i32.const 2552) "\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008") + (data $35 (i32.const 2588) ",") + (data $35.1 (i32.const 2600) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006") + (data $36 (i32.const 2636) ",") + (data $36.1 (i32.const 2648) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002") + (data $37 (i32.const 2684) ",") + (data $37.1 (i32.const 2696) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004") + (data $38 (i32.const 2732) "\1c") + (data $38.1 (i32.const 2744) "\02\00\00\00\08\00\00\00J\00U\00M\00P") + (data $39 (i32.const 2764) ",") + (data $39.1 (i32.const 2776) "\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D") + (data $40 (i32.const 2812) ",") + (data $40.1 (i32.const 2824) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M") + (data $41 (i32.const 2860) ",") + (data $41.1 (i32.const 2872) "\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008") + (data $42 (i32.const 2908) ",") + (data $42.1 (i32.const 2920) "\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008") + (data $43 (i32.const 2956) ",") + (data $43.1 (i32.const 2968) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006") + (data $44 (i32.const 3004) ",") + (data $44.1 (i32.const 3016) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006") + (data $45 (i32.const 3052) ",") + (data $45.1 (i32.const 3064) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002") + (data $46 (i32.const 3100) ",") + (data $46.1 (i32.const 3112) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002") + (data $47 (i32.const 3148) ",") + (data $47.1 (i32.const 3160) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004") + (data $48 (i32.const 3196) ",") + (data $48.1 (i32.const 3208) "\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008") + (data $49 (i32.const 3244) ",") + (data $49.1 (i32.const 3256) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006") + (data $50 (i32.const 3292) ",") + (data $50.1 (i32.const 3304) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002") + (data $51 (i32.const 3340) ",") + (data $51.1 (i32.const 3352) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004") + (data $52 (i32.const 3388) "<") + (data $52.1 (i32.const 3400) "\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008") + (data $53 (i32.const 3452) "<") + (data $53.1 (i32.const 3464) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006") + (data $54 (i32.const 3516) "<") + (data $54.1 (i32.const 3528) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002") + (data $55 (i32.const 3580) "<") + (data $55.1 (i32.const 3592) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004") + (data $56 (i32.const 3644) ",") + (data $56.1 (i32.const 3656) "\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P") + (data $57 (i32.const 3692) ",") + (data $57.1 (i32.const 3704) "\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M") + (data $58 (i32.const 3740) ",") + (data $58.1 (i32.const 3752) "\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M") + (data $59 (i32.const 3788) "<") + (data $59.1 (i32.const 3800) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M") + (data $60 (i32.const 3852) "<") + (data $60.1 (i32.const 3864) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M") + (data $61 (i32.const 3916) "<") + (data $61.1 (i32.const 3928) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M") + (data $62 (i32.const 3980) "<") + (data $62.1 (i32.const 3992) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M") + (data $63 (i32.const 4044) "<") + (data $63.1 (i32.const 4056) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M") + (data $64 (i32.const 4108) "<") + (data $64.1 (i32.const 4120) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M") + (data $65 (i32.const 4172) "<") + (data $65.1 (i32.const 4184) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M") + (data $66 (i32.const 4236) "<") + (data $66.1 (i32.const 4248) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M") + (data $67 (i32.const 4300) ",") + (data $67.1 (i32.const 4312) "\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G") + (data $68 (i32.const 4348) "<") + (data $68.1 (i32.const 4360) "\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004") + (data $69 (i32.const 4412) "<") + (data $69.1 (i32.const 4424) "\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002") + (data $70 (i32.const 4476) "<") + (data $70.1 (i32.const 4488) "\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004") + (data $71 (i32.const 4540) "<") + (data $71.1 (i32.const 4552) "\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002") + (data $72 (i32.const 4604) "<") + (data $72.1 (i32.const 4616) "\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004") + (data $73 (i32.const 4668) "<") + (data $73.1 (i32.const 4680) "\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002") + (data $74 (i32.const 4732) ",") + (data $74.1 (i32.const 4744) "\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008") + (data $75 (i32.const 4780) ",") + (data $75.1 (i32.const 4792) "\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006") + (data $76 (i32.const 4828) ",") + (data $76.1 (i32.const 4840) "\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006") + (data $77 (i32.const 4876) ",") + (data $77.1 (i32.const 4888) "\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S") + (data $78 (i32.const 4924) ",") + (data $78.1 (i32.const 4936) "\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008") + (data $79 (i32.const 4972) ",") + (data $79.1 (i32.const 4984) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006") + (data $80 (i32.const 5020) ",") + (data $80.1 (i32.const 5032) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002") + (data $81 (i32.const 5068) ",") + (data $81.1 (i32.const 5080) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004") + (data $82 (i32.const 5116) ",") + (data $82.1 (i32.const 5128) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008") + (data $83 (i32.const 5164) ",") + (data $83.1 (i32.const 5176) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008") + (data $84 (i32.const 5212) ",") + (data $84.1 (i32.const 5224) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006") + (data $85 (i32.const 5260) ",") + (data $85.1 (i32.const 5272) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006") + (data $86 (i32.const 5308) ",") + (data $86.1 (i32.const 5320) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002") + (data $87 (i32.const 5356) ",") + (data $87.1 (i32.const 5368) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002") + (data $88 (i32.const 5404) ",") + (data $88.1 (i32.const 5416) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004") + (data $89 (i32.const 5452) ",") + (data $89.1 (i32.const 5464) "\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002") + (data $90 (i32.const 5500) ",") + (data $90.1 (i32.const 5512) "\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M") + (data $91 (i32.const 5548) ",") + (data $91.1 (i32.const 5560) "\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M") + (data $92 (i32.const 5596) "\1c") + (data $92.1 (i32.const 5608) "\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M") + (data $93 (i32.const 5628) ",") + (data $93.1 (i32.const 5640) "\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002") + (data $94 (i32.const 5676) ",") + (data $94.1 (i32.const 5688) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M") + (data $95 (i32.const 5724) ",") + (data $95.1 (i32.const 5736) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M") + (data $96 (i32.const 5772) ",") + (data $96.1 (i32.const 5784) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002") + (data $97 (i32.const 5820) ",") + (data $97.1 (i32.const 5832) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002") + (data $98 (i32.const 5868) ",") + (data $98.1 (i32.const 5880) "\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002") + (data $99 (i32.const 5916) ",") + (data $99.1 (i32.const 5928) "\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002") + (data $100 (i32.const 5964) ",") + (data $100.1 (i32.const 5976) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M") + (data $101 (i32.const 6012) ",") + (data $101.1 (i32.const 6024) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M") + (data $102 (i32.const 6060) "<") + (data $102.1 (i32.const 6072) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") + (data $103 (i32.const 6124) "<") + (data $103.1 (i32.const 6136) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") + (data $104 (i32.const 6188) "<") + (data $104.1 (i32.const 6200) "\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") + (data $105 (i32.const 6252) ",") + (data $105.1 (i32.const 6264) "\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M") + (data $106 (i32.const 6300) ",") + (data $106.1 (i32.const 6312) "\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M") + (data $107 (i32.const 6348) ",") + (data $107.1 (i32.const 6360) "\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004") + (data $108 (i32.const 6396) ",") + (data $108.1 (i32.const 6408) "\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004") + (data $109 (i32.const 6444) ",") + (data $109.1 (i32.const 6456) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004") + (data $110 (i32.const 6492) ",") + (data $110.1 (i32.const 6504) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004") + (data $111 (i32.const 6540) ",") + (data $111.1 (i32.const 6552) "\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004") + (data $112 (i32.const 6588) ",") + (data $112.1 (i32.const 6600) "\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004") + (data $113 (i32.const 6636) "<") + (data $113.1 (i32.const 6648) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") + (data $114 (i32.const 6700) "<") + (data $114.1 (i32.const 6712) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") + (data $115 (i32.const 6764) "<") + (data $115.1 (i32.const 6776) "\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") + (data $116 (i32.const 6828) ",") + (data $116.1 (i32.const 6840) "\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M") + (data $117 (i32.const 6876) "<") + (data $117.1 (i32.const 6888) "\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T") + (data $118 (i32.const 6940) ",") + (data $118.1 (i32.const 6952) "\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M") + (data $119 (i32.const 6988) "<") + (data $119.1 (i32.const 7000) "\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T") + (data $120 (i32.const 7052) ",") + (data $120.1 (i32.const 7064) "\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q") + (data $121 (i32.const 7100) ",") + (data $121.1 (i32.const 7112) "\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E") + (data $122 (i32.const 7148) ",") + (data $122.1 (i32.const 7160) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U") + (data $123 (i32.const 7196) ",") + (data $123.1 (i32.const 7208) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S") + (data $124 (i32.const 7244) ",") + (data $124.1 (i32.const 7256) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U") + (data $125 (i32.const 7292) ",") + (data $125.1 (i32.const 7304) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S") + (data $126 (i32.const 7340) "<") + (data $126.1 (i32.const 7352) "\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D") + (data $127 (i32.const 7404) "\1c") + (data $127.1 (i32.const 7416) "\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002") + (data $128 (i32.const 7436) "\1c") + (data $128.1 (i32.const 7448) "\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002") + (data $129 (i32.const 7468) "\1c") + (data $129.1 (i32.const 7480) "\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002") + (data $130 (i32.const 7500) ",") + (data $130.1 (i32.const 7512) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002") + (data $131 (i32.const 7548) ",") + (data $131.1 (i32.const 7560) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002") + (data $132 (i32.const 7596) ",") + (data $132.1 (i32.const 7608) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002") + (data $133 (i32.const 7644) ",") + (data $133.1 (i32.const 7656) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002") + (data $134 (i32.const 7692) ",") + (data $134.1 (i32.const 7704) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002") + (data $135 (i32.const 7740) ",") + (data $135.1 (i32.const 7752) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002") + (data $136 (i32.const 7788) ",") + (data $136.1 (i32.const 7800) "\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002") + (data $137 (i32.const 7836) "\1c") + (data $137.1 (i32.const 7848) "\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004") + (data $138 (i32.const 7868) "\1c") + (data $138.1 (i32.const 7880) "\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004") + (data $139 (i32.const 7900) "\1c") + (data $139.1 (i32.const 7912) "\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004") + (data $140 (i32.const 7932) ",") + (data $140.1 (i32.const 7944) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004") + (data $141 (i32.const 7980) ",") + (data $141.1 (i32.const 7992) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004") + (data $142 (i32.const 8028) ",") + (data $142.1 (i32.const 8040) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004") + (data $143 (i32.const 8076) ",") + (data $143.1 (i32.const 8088) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004") + (data $144 (i32.const 8124) ",") + (data $144.1 (i32.const 8136) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004") + (data $145 (i32.const 8172) ",") + (data $145.1 (i32.const 8184) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004") + (data $146 (i32.const 8220) ",") + (data $146.1 (i32.const 8232) "\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004") + (data $147 (i32.const 8268) "\1c") + (data $147.1 (i32.const 8280) "\02\00\00\00\06\00\00\00A\00N\00D") + (data $148 (i32.const 8300) "\1c") + (data $148.1 (i32.const 8312) "\02\00\00\00\06\00\00\00X\00O\00R") + (data $149 (i32.const 8332) "\1c") + (data $149.1 (i32.const 8344) "\02\00\00\00\04\00\00\00O\00R") + (data $150 (i32.const 8364) ",") + (data $150.1 (i32.const 8376) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S") + (data $151 (i32.const 8412) ",") + (data $151.1 (i32.const 8424) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U") + (data $152 (i32.const 8460) ",") + (data $152.1 (i32.const 8472) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U") + (data $153 (i32.const 8508) ",") + (data $153.1 (i32.const 8520) "\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U") + (data $154 (i32.const 8556) ",") + (data $154.1 (i32.const 8568) "\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S") + (data $155 (i32.const 8604) ",") + (data $155.1 (i32.const 8616) "\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z") + (data $156 (i32.const 8652) ",") + (data $156.1 (i32.const 8664) "\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z") + (data $157 (i32.const 8700) ",") + (data $157.1 (i32.const 8712) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004") + (data $158 (i32.const 8748) ",") + (data $158.1 (i32.const 8760) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002") + (data $159 (i32.const 8796) ",") + (data $159.1 (i32.const 8808) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004") + (data $160 (i32.const 8844) ",") + (data $160.1 (i32.const 8856) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002") + (data $161 (i32.const 8892) ",") + (data $161.1 (i32.const 8904) "\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V") + (data $162 (i32.const 8940) "\1c") + (data $162.1 (i32.const 8952) "\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V") + (data $163 (i32.const 8972) "\1c") + (data $163.1 (i32.const 8984) "\02\00\00\00\08\00\00\00X\00N\00O\00R") + (data $164 (i32.const 9004) "\1c") + (data $164.1 (i32.const 9016) "\02\00\00\00\06\00\00\00M\00A\00X") + (data $165 (i32.const 9036) "\1c") + (data $165.1 (i32.const 9048) "\02\00\00\00\n\00\00\00M\00A\00X\00_\00U") + (data $166 (i32.const 9068) "\1c") + (data $166.1 (i32.const 9080) "\02\00\00\00\06\00\00\00M\00I\00N") + (data $167 (i32.const 9100) "\1c") + (data $167.1 (i32.const 9112) "\02\00\00\00\n\00\00\00M\00I\00N\00_\00U") + (data $168 (i32.const 9132) ",") + (data $168.1 (i32.const 9144) "\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s") + (data $169 (i32.const 9180) ",") + (data $169.1 (i32.const 9192) "\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h") + (data $170 (i32.const 9228) "<") + (data $170.1 (i32.const 9240) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s") + (data $171 (i32.const 9292) "<") + (data $171.1 (i32.const 9304) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s") + (data $172 (i32.const 9356) "\1c") + (data $172.1 (i32.const 9368) "\14\00\00\00\08\00\00\00\0e") + (data $173 (i32.const 9388) "\1c") + (data $173.1 (i32.const 9400) "\14\00\00\00\08\00\00\00\0f") + (data $174 (i32.const 9420) "\1c") + (data $174.1 (i32.const 9432) "\14\00\00\00\08\00\00\00\10") + (data $175 (i32.const 9452) "\1c") + (data $175.1 (i32.const 9464) "\14\00\00\00\08\00\00\00\11") + (data $176 (i32.const 9484) "\1c") + (data $176.1 (i32.const 9496) "\14\00\00\00\08\00\00\00\12") + (data $177 (i32.const 9516) "\1c") + (data $177.1 (i32.const 9528) "\14\00\00\00\08\00\00\00\13") + (data $178 (i32.const 9548) "\1c") + (data $178.1 (i32.const 9560) "\14\00\00\00\08\00\00\00\14") + (data $179 (i32.const 9580) "\1c") + (data $179.1 (i32.const 9592) "\14\00\00\00\08\00\00\00\15") + (data $180 (i32.const 9612) "\1c") + (data $180.1 (i32.const 9624) "\14\00\00\00\08\00\00\00\16") + (data $181 (i32.const 9644) "\1c") + (data $181.1 (i32.const 9656) "\14\00\00\00\08\00\00\00\17") + (data $182 (i32.const 9676) "\1c") + (data $182.1 (i32.const 9688) "\14\00\00\00\08\00\00\00\18") + (data $183 (i32.const 9708) "\1c") + (data $183.1 (i32.const 9720) "\14\00\00\00\08\00\00\00\19") + (data $184 (i32.const 9740) "\1c") + (data $184.1 (i32.const 9752) "\14\00\00\00\08\00\00\00\1a") + (data $185 (i32.const 9772) "\1c") + (data $185.1 (i32.const 9784) "\14\00\00\00\08\00\00\00\1b") + (data $186 (i32.const 9804) "\1c") + (data $186.1 (i32.const 9816) "\14\00\00\00\08\00\00\00\1c") + (data $187 (i32.const 9836) "\1c") + (data $187.1 (i32.const 9848) "\14\00\00\00\08\00\00\00\1d") + (data $188 (i32.const 9868) "\1c") + (data $188.1 (i32.const 9880) "\14\00\00\00\08\00\00\00\1e") + (data $189 (i32.const 9900) "\1c") + (data $189.1 (i32.const 9912) "\14\00\00\00\08\00\00\00\1f") + (data $190 (i32.const 9932) "\1c") + (data $190.1 (i32.const 9944) "\14\00\00\00\08\00\00\00 ") + (data $191 (i32.const 9964) "\1c") + (data $191.1 (i32.const 9976) "\14\00\00\00\08\00\00\00!") + (data $192 (i32.const 9996) "\1c") + (data $192.1 (i32.const 10008) "\14\00\00\00\08\00\00\00\"") + (data $193 (i32.const 10028) "\1c") + (data $193.1 (i32.const 10040) "\14\00\00\00\08\00\00\00#") + (data $194 (i32.const 10060) "\1c") + (data $194.1 (i32.const 10072) "\14\00\00\00\08\00\00\00$") + (data $195 (i32.const 10092) "\1c") + (data $195.1 (i32.const 10104) "\14\00\00\00\08\00\00\00%") + (data $196 (i32.const 10124) "\1c") + (data $196.1 (i32.const 10136) "\14\00\00\00\08\00\00\00&") + (data $197 (i32.const 10156) "\1c") + (data $197.1 (i32.const 10168) "\14\00\00\00\08\00\00\00\'") + (data $198 (i32.const 10188) "\1c") + (data $198.1 (i32.const 10200) "\14\00\00\00\08\00\00\00(") + (data $199 (i32.const 10220) "\1c") + (data $199.1 (i32.const 10232) "\14\00\00\00\08\00\00\00)") + (data $200 (i32.const 10252) "\1c") + (data $200.1 (i32.const 10264) "\14\00\00\00\08\00\00\00*") + (data $201 (i32.const 10284) "\1c") + (data $201.1 (i32.const 10296) "\14\00\00\00\08\00\00\00+") + (data $202 (i32.const 10316) "\1c") + (data $202.1 (i32.const 10328) "\14\00\00\00\08\00\00\00,") + (data $203 (i32.const 10348) "\1c") + (data $203.1 (i32.const 10360) "\14\00\00\00\08\00\00\00-") + (data $204 (i32.const 10380) "<") + (data $204.1 (i32.const 10392) "\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t") + (data $205 (i32.const 10444) ",") + (data $205.1 (i32.const 10456) "\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s") + (data $206 (i32.const 10492) "|") + (data $206.1 (i32.const 10504) "\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)") + (data $207 (i32.const 10620) "L") + (data $207.1 (i32.const 10632) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s") + (data $208 (i32.const 10700) "\1c") + (data $208.1 (i32.const 10712) "\14\00\00\00\08\00\00\00.") + (data $209 (i32.const 10732) "\1c") + (data $209.1 (i32.const 10744) "\14\00\00\00\08\00\00\00/") + (data $210 (i32.const 10764) "\1c") + (data $210.1 (i32.const 10776) "\14\00\00\00\08\00\00\000") + (data $211 (i32.const 10796) "\1c") + (data $211.1 (i32.const 10808) "\14\00\00\00\08\00\00\001") + (data $212 (i32.const 10828) "\1c") + (data $212.1 (i32.const 10840) "\14\00\00\00\08\00\00\002") + (data $213 (i32.const 10860) "\1c") + (data $213.1 (i32.const 10872) "\14\00\00\00\08\00\00\003") + (data $214 (i32.const 10892) "\1c") + (data $214.1 (i32.const 10904) "\14\00\00\00\08\00\00\004") + (data $215 (i32.const 10924) "\1c") + (data $215.1 (i32.const 10936) "\14\00\00\00\08\00\00\005") + (data $216 (i32.const 10956) "\1c") + (data $216.1 (i32.const 10968) "\14\00\00\00\08\00\00\006") + (data $217 (i32.const 10988) "\1c") + (data $217.1 (i32.const 11000) "\14\00\00\00\08\00\00\007") + (data $218 (i32.const 11020) "\1c") + (data $218.1 (i32.const 11032) "\14\00\00\00\08\00\00\008") + (data $219 (i32.const 11052) "\1c") + (data $219.1 (i32.const 11064) "\14\00\00\00\08\00\00\009") + (data $220 (i32.const 11084) "\1c") + (data $220.1 (i32.const 11096) "\14\00\00\00\08\00\00\00:") + (data $221 (i32.const 11116) "\1c") + (data $221.1 (i32.const 11128) "\14\00\00\00\08\00\00\00;") + (data $222 (i32.const 11148) "\1c") + (data $222.1 (i32.const 11160) "\14\00\00\00\08\00\00\00<") + (data $223 (i32.const 11180) "\1c") + (data $223.1 (i32.const 11192) "\14\00\00\00\08\00\00\00=") + (data $224 (i32.const 11212) "\1c") + (data $224.1 (i32.const 11224) "\14\00\00\00\08\00\00\00>") + (data $225 (i32.const 11244) "\1c") + (data $225.1 (i32.const 11256) "\14\00\00\00\08\00\00\00?") + (data $226 (i32.const 11276) "\1c") + (data $226.1 (i32.const 11288) "\14\00\00\00\08\00\00\00@") + (data $227 (i32.const 11308) "\1c") + (data $227.1 (i32.const 11320) "\14\00\00\00\08\00\00\00A") + (data $228 (i32.const 11340) "\1c") + (data $228.1 (i32.const 11352) "\14\00\00\00\08\00\00\00B") + (data $229 (i32.const 11372) "\1c") + (data $229.1 (i32.const 11384) "\14\00\00\00\08\00\00\00C") + (data $230 (i32.const 11404) "\1c") + (data $230.1 (i32.const 11416) "\14\00\00\00\08\00\00\00D") + (data $231 (i32.const 11436) "\1c") + (data $231.1 (i32.const 11448) "\14\00\00\00\08\00\00\00E") + (data $232 (i32.const 11468) "\1c") + (data $232.1 (i32.const 11480) "\14\00\00\00\08\00\00\00F") + (data $233 (i32.const 11500) "\1c") + (data $233.1 (i32.const 11512) "\14\00\00\00\08\00\00\00G") + (data $234 (i32.const 11532) "\1c") + (data $234.1 (i32.const 11544) "\14\00\00\00\08\00\00\00H") + (data $235 (i32.const 11564) "\1c") + (data $235.1 (i32.const 11576) "\14\00\00\00\08\00\00\00I") + (data $236 (i32.const 11596) "\1c") + (data $236.1 (i32.const 11608) "\14\00\00\00\08\00\00\00J") + (data $237 (i32.const 11628) "\1c") + (data $237.1 (i32.const 11640) "\14\00\00\00\08\00\00\00K") + (data $238 (i32.const 11660) "\1c") + (data $238.1 (i32.const 11672) "\14\00\00\00\08\00\00\00L") + (data $239 (i32.const 11692) "\1c") + (data $239.1 (i32.const 11704) "\14\00\00\00\08\00\00\00M") + (data $240 (i32.const 11724) "\1c") + (data $240.1 (i32.const 11736) "\14\00\00\00\08\00\00\00N") + (data $241 (i32.const 11756) "\1c") + (data $241.1 (i32.const 11768) "\14\00\00\00\08\00\00\00O") + (data $242 (i32.const 11788) "\1c") + (data $242.1 (i32.const 11800) "\14\00\00\00\08\00\00\00P") + (data $243 (i32.const 11820) "\1c") + (data $243.1 (i32.const 11832) "\14\00\00\00\08\00\00\00Q") + (data $244 (i32.const 11852) "\1c") + (data $244.1 (i32.const 11864) "\14\00\00\00\08\00\00\00R") + (data $245 (i32.const 11884) "\1c") + (data $245.1 (i32.const 11896) "\14\00\00\00\08\00\00\00S") + (data $246 (i32.const 11916) "\1c") + (data $246.1 (i32.const 11928) "\14\00\00\00\08\00\00\00T") + (data $247 (i32.const 11948) "\1c") + (data $247.1 (i32.const 11960) "\14\00\00\00\08\00\00\00U") + (data $248 (i32.const 11980) "\1c") + (data $248.1 (i32.const 11992) "\14\00\00\00\08\00\00\00V") + (data $249 (i32.const 12012) "\1c") + (data $249.1 (i32.const 12024) "\14\00\00\00\08\00\00\00W") + (data $250 (i32.const 12044) "\1c") + (data $250.1 (i32.const 12056) "\14\00\00\00\08\00\00\00X") + (data $251 (i32.const 12076) "\1c") + (data $251.1 (i32.const 12088) "\14\00\00\00\08\00\00\00Y") + (data $252 (i32.const 12108) "\1c") + (data $252.1 (i32.const 12120) "\14\00\00\00\08\00\00\00Z") + (data $253 (i32.const 12140) "\1c") + (data $253.1 (i32.const 12152) "\14\00\00\00\08\00\00\00[") + (data $254 (i32.const 12172) "\1c") + (data $254.1 (i32.const 12184) "\14\00\00\00\08\00\00\00\\") + (data $255 (i32.const 12204) "\1c") + (data $255.1 (i32.const 12216) "\14\00\00\00\08\00\00\00]") + (data $256 (i32.const 12236) "\1c") + (data $256.1 (i32.const 12248) "\14\00\00\00\08\00\00\00^") + (data $257 (i32.const 12268) "\1c") + (data $257.1 (i32.const 12280) "\14\00\00\00\08\00\00\00_") + (data $258 (i32.const 12300) "\1c") + (data $258.1 (i32.const 12312) "\14\00\00\00\08\00\00\00`") + (data $259 (i32.const 12332) "\1c") + (data $259.1 (i32.const 12344) "\14\00\00\00\08\00\00\00a") + (data $260 (i32.const 12364) "\1c") + (data $260.1 (i32.const 12376) "\14\00\00\00\08\00\00\00b") + (data $261 (i32.const 12396) "\1c") + (data $261.1 (i32.const 12408) "\14\00\00\00\08\00\00\00c") + (data $262 (i32.const 12428) "\1c") + (data $262.1 (i32.const 12440) "\14\00\00\00\08\00\00\00d") + (data $263 (i32.const 12460) "\1c") + (data $263.1 (i32.const 12472) "\14\00\00\00\08\00\00\00e") + (data $264 (i32.const 12492) "\1c") + (data $264.1 (i32.const 12504) "\14\00\00\00\08\00\00\00f") + (data $265 (i32.const 12524) "\1c") + (data $265.1 (i32.const 12536) "\14\00\00\00\08\00\00\00g") + (data $266 (i32.const 12556) "\1c") + (data $266.1 (i32.const 12568) "\14\00\00\00\08\00\00\00h") + (data $267 (i32.const 12588) "\1c") + (data $267.1 (i32.const 12600) "\14\00\00\00\08\00\00\00i") + (data $268 (i32.const 12620) "\1c") + (data $268.1 (i32.const 12632) "\14\00\00\00\08\00\00\00j") + (data $269 (i32.const 12652) "\1c") + (data $269.1 (i32.const 12664) "\14\00\00\00\08\00\00\00k") + (data $270 (i32.const 12684) "\1c") + (data $270.1 (i32.const 12696) "\14\00\00\00\08\00\00\00l") + (data $271 (i32.const 12716) "\1c") + (data $271.1 (i32.const 12728) "\14\00\00\00\08\00\00\00m") + (data $272 (i32.const 12748) "\1c") + (data $272.1 (i32.const 12760) "\14\00\00\00\08\00\00\00n") + (data $273 (i32.const 12780) "\1c") + (data $273.1 (i32.const 12792) "\14\00\00\00\08\00\00\00o") + (data $274 (i32.const 12812) "\1c") + (data $274.1 (i32.const 12824) "\14\00\00\00\08\00\00\00p") + (data $275 (i32.const 12844) "\1c") + (data $275.1 (i32.const 12856) "\14\00\00\00\08\00\00\00q") + (data $276 (i32.const 12876) "\1c") + (data $276.1 (i32.const 12888) "\14\00\00\00\08\00\00\00r") + (data $277 (i32.const 12908) "\1c") + (data $277.1 (i32.const 12920) "\14\00\00\00\08\00\00\00s") + (data $278 (i32.const 12940) "\1c") + (data $278.1 (i32.const 12952) "\14\00\00\00\08\00\00\00t") + (data $279 (i32.const 12972) "\1c") + (data $279.1 (i32.const 12984) "\14\00\00\00\08\00\00\00u") + (data $280 (i32.const 13004) "\1c") + (data $280.1 (i32.const 13016) "\14\00\00\00\08\00\00\00v") + (data $281 (i32.const 13036) "\1c") + (data $281.1 (i32.const 13048) "\14\00\00\00\08\00\00\00w") + (data $282 (i32.const 13068) "\1c") + (data $282.1 (i32.const 13080) "\14\00\00\00\08\00\00\00x") + (data $283 (i32.const 13100) "\1c") + (data $283.1 (i32.const 13112) "\14\00\00\00\08\00\00\00y") + (data $284 (i32.const 13132) "\1c") + (data $284.1 (i32.const 13144) "\14\00\00\00\08\00\00\00z") + (data $285 (i32.const 13164) "\1c") + (data $285.1 (i32.const 13176) "\14\00\00\00\08\00\00\00{") + (data $286 (i32.const 13196) "\1c") + (data $286.1 (i32.const 13208) "\14\00\00\00\08\00\00\00|") + (data $287 (i32.const 13228) "\1c") + (data $287.1 (i32.const 13240) "\14\00\00\00\08\00\00\00}") + (data $288 (i32.const 13260) "\1c") + (data $288.1 (i32.const 13272) "\14\00\00\00\08\00\00\00~") + (data $289 (i32.const 13292) "\1c") + (data $289.1 (i32.const 13304) "\14\00\00\00\08\00\00\00\7f") + (data $290 (i32.const 13324) "\1c") + (data $290.1 (i32.const 13336) "\14\00\00\00\08\00\00\00\80") + (data $291 (i32.const 13356) "\1c") + (data $291.1 (i32.const 13368) "\14\00\00\00\08\00\00\00\81") + (data $292 (i32.const 13388) "\1c") + (data $292.1 (i32.const 13400) "\14\00\00\00\08\00\00\00\82") + (data $293 (i32.const 13420) "\1c") + (data $293.1 (i32.const 13432) "\14\00\00\00\08\00\00\00\83") + (data $294 (i32.const 13452) "\1c") + (data $294.1 (i32.const 13464) "\14\00\00\00\08\00\00\00\84") + (data $295 (i32.const 13484) "\1c") + (data $295.1 (i32.const 13496) "\14\00\00\00\08\00\00\00\85") + (data $296 (i32.const 13516) "\1c") + (data $296.1 (i32.const 13528) "\14\00\00\00\08\00\00\00\86") + (data $297 (i32.const 13548) "\1c") + (data $297.1 (i32.const 13560) "\14\00\00\00\08\00\00\00\87") + (data $298 (i32.const 13580) "\1c") + (data $298.1 (i32.const 13592) "\14\00\00\00\08\00\00\00\88") + (data $299 (i32.const 13612) "\1c") + (data $299.1 (i32.const 13624) "\14\00\00\00\08\00\00\00\89") + (data $300 (i32.const 13644) "\1c") + (data $300.1 (i32.const 13656) "\14\00\00\00\08\00\00\00\8a") + (data $301 (i32.const 13676) "\1c") + (data $301.1 (i32.const 13688) "\14\00\00\00\08\00\00\00\8b") + (data $302 (i32.const 13708) "\1c") + (data $302.1 (i32.const 13720) "\14\00\00\00\08\00\00\00\8c") + (data $303 (i32.const 13740) "\1c") + (data $303.1 (i32.const 13752) "\14\00\00\00\08\00\00\00\8d") + (data $304 (i32.const 13772) "\1c") + (data $304.1 (i32.const 13784) "\14\00\00\00\08\00\00\00\8e") + (data $305 (i32.const 13804) "\1c") + (data $305.1 (i32.const 13816) "\14\00\00\00\08\00\00\00\8f") + (data $306 (i32.const 13836) "\1c") + (data $306.1 (i32.const 13848) "\14\00\00\00\08\00\00\00\90") + (data $307 (i32.const 13868) "\1c") + (data $307.1 (i32.const 13880) "\14\00\00\00\08\00\00\00\91") + (data $308 (i32.const 13900) "\1c") + (data $308.1 (i32.const 13912) "\14\00\00\00\08\00\00\00\92") + (data $309 (i32.const 13932) "\1c") + (data $309.1 (i32.const 13944) "\14\00\00\00\08\00\00\00\93") + (data $310 (i32.const 13964) "\1c") + (data $310.1 (i32.const 13976) "\14\00\00\00\08\00\00\00\94") + (data $311 (i32.const 13996) "\1c") + (data $311.1 (i32.const 14008) "\14\00\00\00\08\00\00\00\95") + (data $312 (i32.const 14028) "\1c") + (data $312.1 (i32.const 14040) "\14\00\00\00\08\00\00\00\96") + (data $313 (i32.const 14060) "\1c") + (data $313.1 (i32.const 14072) "\14\00\00\00\08\00\00\00\97") + (data $314 (i32.const 14092) "\1c") + (data $314.1 (i32.const 14104) "\14\00\00\00\08\00\00\00\98") + (data $315 (i32.const 14124) ",") + (data $315.1 (i32.const 14136) "\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y") + (data $316 (i32.const 14172) "\\") + (data $316.1 (i32.const 14184) "\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.") + (data $317 (i32.const 14268) "\1c") + (data $317.1 (i32.const 14280) "\14\00\00\00\08\00\00\00\99") + (data $318 (i32.const 14300) "\ac\03") + (data $318.1 (i32.const 14312) "\01\00\00\00\9c\03\00\00\e06\00\00\007\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 7\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00`(\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c04\00\00\e04\00\00\005\00\00 5\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\e0\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\00(\00\00\80(\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\00`*\00\00\80*\00\00\a0*\00\00@5\00\00`5\00\00\805\00\00\a05\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c05\00\00\e05\00\00\006\00\00 6\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 (\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00\c0&\00\00\e0&\00\00\00\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 0\00\00\d07\00\00\a0$\00\00\c0$\00\00\e0$\00\00\00%\00\00 %\00\00@%\00\00`%\00\00\80%\00\00\a0%\00\00\c0%\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00@6\00\00`6\00\00\806\00\00\a06\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00@+\00\00`+\00\00\80+\00\00\c0,\00\00\a0+\00\00\c0+\00\00\e0+\00\00\e0,\00\00\c01\00\00\e01\00\00\802\00\00\a02\00\00\c02\00\00\00-\00\00\002\00\00 2\00\00\e02\00\00\003\00\00 3\00\00@0\00\00`0\00\00 -\00\00@-\00\00@3\00\00`3\00\00\803\00\00`-\00\00\a03\00\00\c03\00\00\e03\00\00\c00\00\00\e00\00\00\001\00\00 1\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\a0\'\00\00\c0\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00@(\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\80-\00\00\a0-\00\00\c0-\00\00\e0-\00\00\00.\00\00 .\00\00@.\00\00\004\00\00 4\00\00@4\00\00`.\00\00\80.\00\00\a0.\00\00\c0.\00\00\e0.\00\00\00/\00\00 /\00\00`4\00\00\804\00\00\a04\00\00\00,\00\00 ,\00\00@,\00\00@/\00\00`/\00\00\80/\00\00@2\00\00`2\00\00\800\00\00\a00\00\00@1\00\00`1\00\00\801\00\00\a01\00\00`,\00\00\80,\00\00\a0,\00\00\a0/\00\00\c0/\00\00\e0/\00\00\000") + (data $319 (i32.const 15244) ",") + (data $319.1 (i32.const 15256) "\1a\00\00\00\10\00\00\00\f07\00\00\f07\00\00\9c\03\00\00\e7") + (data $320 (i32.const 15292) "\1c") + (data $320.1 (i32.const 15304) "\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80") + (data $321 (i32.const 15324) ",") + (data $321.1 (i32.const 15336) "\1b\00\00\00\10\00\00\00\d0;\00\00\d0;\00\00\08\00\00\00\08") + (data $322 (i32.const 15372) "\1c") + (data $322.1 (i32.const 15384) "\1c\00\00\00\08\00\00\00\9a") + (data $323 (i32.const 15404) "\1c") + (data $323.1 (i32.const 15416) "\02") + (data $324 (i32.const 15436) "L") + (data $324.1 (i32.const 15448) "\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 ") + (data $325 (i32.const 15516) ",") + (data $325.1 (i32.const 15528) "\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 ") + (data $326 (i32.const 15564) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00`<\00\00\00\00\00\00\b0<") + (data $327 (i32.const 15612) "|") + (data $327.1 (i32.const 15624) "\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006") + (data $328 (i32.const 15740) "<") + (data $328.1 (i32.const 15752) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s") + (data $329 (i32.const 15804) "\1c") + (data $329.1 (i32.const 15816) "\02\00\00\00\02\00\00\000") + (data $330 (i32.const 15836) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009") + (data $331 (i32.const 16236) "\1c\04") + (data $331.1 (i32.const 16248) "\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f") + (data $332 (i32.const 17292) "\\") + (data $332.1 (i32.const 17304) "\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z") + (data $333 (i32.const 17388) "<") + (data $333.1 (i32.const 17400) "\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s") + (data $334 (i32.const 17452) "l") + (data $334.1 (i32.const 17464) "\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 ") + (data $335 (i32.const 17564) ",") + (data $335.1 (i32.const 17576) "\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 ") + (data $336 (i32.const 17612) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00@D\00\00\00\00\00\00\b0D") + (data $337 (i32.const 17660) ",") + (data $337.1 (i32.const 17672) "\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n") + (data $338 (i32.const 17708) "\1c") + (data $338.1 (i32.const 17720) "\02\00\00\00\04\00\00\000\00x") + (data $339 (i32.const 17740) "\1c") + (data $339.1 (i32.const 17752) ")\00\00\00\08\00\00\00\9b") + (data $340 (i32.const 17772) "\1c") + (data $340.1 (i32.const 17784) "\02\00\00\00\04\00\00\00\n\00\n") + (data $341 (i32.const 17804) "|") + (data $341.1 (i32.const 17816) "\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y") + (data $342 (i32.const 17932) "L") + (data $342.1 (i32.const 17944) "\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>") + (data $343 (i32.const 18012) "l") + (data $343.1 (i32.const 18024) "\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!") + (data $344 (i32.const 18124) "L") + (data $344.1 (i32.const 18136) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00g\00e\00n\00e\00r\00i\00c\00.\00t\00s") + (data $345 (i32.const 18204) "\1c") + (data $345.1 (i32.const 18216) "\02\00\00\00\02\00\00\00\n") + (data $346 (i32.const 18236) "\1c") + (data $346.1 (i32.const 18248) "\02\00\00\00\04\00\00\00:\00 ") + (data $347 (i32.const 18268) "\1c") + (data $347.1 (i32.const 18280) "\02\00\00\00\02\00\00\00(") + (data $348 (i32.const 18300) "\1c") + (data $348.1 (i32.const 18312) "\02\00\00\00\02\00\00\00)") + (data $349 (i32.const 18332) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pG\00\00\00\00\00\00\90G") + (data $350 (i32.const 18364) "\1c") + (data $350.1 (i32.const 18376) "\02\00\00\00\02\00\00\00 ") + (data $351 (i32.const 18396) "\1c") + (data $351.1 (i32.const 18408) "\02\00\00\00\04\00\00\00,\00 ") + (data $352 (i32.const 18428) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00\d0G\00\00\00\00\00\00\f0G") + (data $353 (i32.const 18460) "|") + (data $353.1 (i32.const 18472) "\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 ") + (data $354 (i32.const 18588) ",") + (data $354.1 (i32.const 18600) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 ") + (data $355 (i32.const 18636) "\1c") + (data $355.1 (i32.const 18648) "\01") + (data $356 (i32.const 18668) "\1c") + (data $356.1 (i32.const 18680) "\01") + (data $357 (i32.const 18700) "\1c") + (data $357.1 (i32.const 18712) "\01") + (data $358 (i32.const 18732) "\1c") + (data $358.1 (i32.const 18744) "\01") + (data $359 (i32.const 18764) "\\") + (data $359.1 (i32.const 18776) "\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 ") + (data $360 (i32.const 18860) "<") + (data $360.1 (i32.const 18872) "\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s") + (data $361 (i32.const 18924) "l") + (data $361.1 (i32.const 18936) "\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!") + (data $362 (i32.const 19036) ",") + (data $362.1 (i32.const 19048) "\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 ") + (data $363 (i32.const 19084) ",") + (data $363.1 (i32.const 19096) "\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)") + (data $364 (i32.const 19132) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pJ\00\00\00\00\00\00\a0J") + (data $365 (i32.const 19164) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pJ\00\00\00\00\00\00\a0J") + (data $366 (i32.const 19196) "\1c") + (data $366.1 (i32.const 19208) "5\00\00\00\08\00\00\00\9c") + (data $367 (i32.const 19228) "<") + (data $367.1 (i32.const 19240) "\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 ") + (data $368 (i32.const 19292) "\1c") + (data $368.1 (i32.const 19304) "\02\00\00\00\n\00\00\00P\00C\00 \00=\00 ") + (data $369 (i32.const 19324) ",") + (data $369.1 (i32.const 19336) "\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 ") + (data $370 (i32.const 19372) "\1c") + (data $370.1 (i32.const 19384) "5\00\00\00\08\00\00\00\9d") + (data $371 (i32.const 19404) ",") + (data $371.1 (i32.const 19416) "\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 ") + (data $372 (i32.const 19452) "\1c") + (data $372.1 (i32.const 19464) "\02\00\00\00\04\00\00\00 \00(") + (data $373 (i32.const 19484) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\14\00\00\00\e0K\00\00\00\00\00\00\10L\00\00\00\00\00\00\90G") + (data $374 (i32.const 19532) "L") + (data $374.1 (i32.const 19544) "\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 ") + (data $375 (i32.const 19612) "<") + (data $375.1 (i32.const 19624) "\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s") + (data $376 (i32.const 19676) ",") + (data $376.1 (i32.const 19688) "\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 ") + (data $377 (i32.const 19724) "\1c") + (data $377.1 (i32.const 19736) "\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x") + (data $378 (i32.const 19756) "\1c") + (data $378.1 (i32.const 19768) "\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 ") + (data $379 (i32.const 19788) "\1c") + (data $379.1 (i32.const 19800) "\02\00\00\00\08\00\00\00,\00\n\00 \00 ") + (data $380 (i32.const 19820) "|\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00`\00\00\00\f0L\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00@M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00`M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00`M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M") + (data $381 (i32.const 19948) ",") + (data $381.1 (i32.const 19960) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t") + (data $382 (i32.const 19996) "L") + (data $382.1 (i32.const 20008) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s") + (data $383 (i32.const 20076) "\1c") + (data $383.1 (i32.const 20088) "\01") + (data $384 (i32.const 20108) "\1c") + (data $384.1 (i32.const 20120) "\01") + (data $385 (i32.const 20140) "\1c") + (data $385.1 (i32.const 20152) "\01") + (data $386 (i32.const 20172) "\1c") + (data $386.1 (i32.const 20184) "\01") + (data $387 (i32.const 20204) "L") + (data $387.1 (i32.const 20216) "\02\00\00\00:\00\00\00S\00P\00I\00 \00r\00u\00n\00n\00i\00n\00g\00 \00n\00o\00t\00 \00s\00u\00p\00p\00o\00r\00t\00e\00d\00 \00y\00e\00t") + (data $388 (i32.const 20284) "<") + (data $388.1 (i32.const 20296) "\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00d\00e\00x\00.\00t\00s") + (data $389 (i32.const 20348) "L") + (data $389.1 (i32.const 20360) "\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s") + (data $390 (i32.const 20428) "\1c") + (data $390.1 (i32.const 20440) "\01") + (data $391 (i32.const 20460) "<") + (data $391.1 (i32.const 20472) "\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s") + (data $392 (i32.const 20524) "L") + (data $392.1 (i32.const 20536) "\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 ") + (data $393 (i32.const 20604) "\\") + (data $393.1 (i32.const 20616) "\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 ") + (data $394 (i32.const 20700) ",") + (data $394.1 (i32.const 20712) "\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 ") + (data $395 (i32.const 20748) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00\90P\00\00\00\00\00\00\f0P") + (data $396 (i32.const 20796) "<") + (data $396.1 (i32.const 20808) "\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00.\00t\00s") + (data $397 (i32.const 20860) "\1c") + (data $397.1 (i32.const 20872) "\01") + (data $398 (i32.const 20892) "\1c") + (data $398.1 (i32.const 20904) "\01") + (data $399 (i32.const 20924) "<") + (data $399.1 (i32.const 20936) "\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d") + (data $400 (i32.const 20988) "<") + (data $400.1 (i32.const 21000) "\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d") + (data $401 (i32.const 21056) "<\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 ") + (data $401.1 (i32.const 21116) "$\02") + (data $401.2 (i32.const 21128) "\02A\00\00\10A\02\00 ") + (data $401.3 (i32.const 21152) "d") + (data $401.4 (i32.const 21164) "\02A\00\00B") + (data $401.5 (i32.const 21188) "$\01") + (data $401.6 (i32.const 21200) "$\t\00\00 ") + (data $401.7 (i32.const 21216) "\04A\00\00 \00\00\00\00\00\00\00\02\01\00\00\02\02") + (data $401.8 (i32.const 21244) "\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A") + (data $401.9 (i32.const 21280) " \00\00\00 \00\00\00\02A\00\00d") + (table $0 158 158 funcref) + (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $assembly/index/disassemble~anonymous|0 $assembly/api-generic/runVm~anonymous|0 $assembly/api-generic/runVm~anonymous|0) + (export "InputKind.Generic" (global $assembly/index/InputKind.Generic)) + (export "InputKind.SPI" (global $assembly/index/InputKind.SPI)) + (export "HasMetadata.Yes" (global $assembly/index/HasMetadata.Yes)) + (export "HasMetadata.No" (global $assembly/index/HasMetadata.No)) + (export "nextStep" (func $assembly/api/nextStep)) + (export "nSteps" (func $assembly/api/nSteps)) + (export "getProgramCounter" (func $assembly/api/getProgramCounter)) + (export "setNextProgramCounter" (func $assembly/api/setNextProgramCounter)) + (export "getStatus" (func $assembly/api/getStatus)) + (export "getExitArg" (func $assembly/api/getExitArg)) + (export "getGasLeft" (func $assembly/api/getGasLeft)) + (export "setGasLeft" (func $assembly/api/setGasLeft)) + (export "getRegisters" (func $assembly/api/getRegisters)) + (export "getPageDump" (func $assembly/api/getPageDump)) + (export "__new" (func $~lib/rt/itcms/__new)) + (export "__pin" (func $~lib/rt/itcms/__pin)) + (export "__unpin" (func $~lib/rt/itcms/__unpin)) + (export "__collect" (func $~lib/rt/itcms/__collect)) + (export "__rtti_base" (global $~lib/rt/__rtti_base)) + (export "memory" (memory $0)) + (export "__setArgumentsLength" (func $~setArgumentsLength)) + (export "disassemble" (func $export:assembly/index/disassemble)) + (export "runProgram" (func $export:assembly/index/runProgram)) + (export "runVm" (func $export:assembly/api-generic/runVm@varargs)) + (export "getAssembly" (func $export:assembly/api-generic/getAssembly)) + (export "wrapAsProgram" (func $export:assembly/program-build/wrapAsProgram)) + (export "resetGeneric" (func $export:assembly/api/resetGeneric)) + (export "resetGenericWithMemory" (func $export:assembly/api/resetGenericWithMemory)) + (export "setRegisters" (func $export:assembly/api/setRegisters)) + (export "setMemory" (func $export:assembly/api/setMemory)) + (start $~start) + (func $~lib/rt/itcms/visitRoots + (local $0 i32) + (local $1 i32) + i32.const 1504 + call $~lib/rt/itcms/__visit + i32.const 9200 + call $~lib/rt/itcms/__visit + i32.const 14144 + call $~lib/rt/itcms/__visit + i32.const 17824 + call $~lib/rt/itcms/__visit + i32.const 10400 + call $~lib/rt/itcms/__visit + i32.const 1312 + call $~lib/rt/itcms/__visit + i32.const 20944 + call $~lib/rt/itcms/__visit + i32.const 21008 + call $~lib/rt/itcms/__visit + i32.const 16256 + call $~lib/rt/itcms/__visit + i32.const 17312 + call $~lib/rt/itcms/__visit + global.get $assembly/api/interpreter + local.tee $0 + if + local.get $0 + call $~lib/rt/itcms/__visit + end + i32.const 1136 + call $~lib/rt/itcms/__visit + i32.const 1264 + call $~lib/rt/itcms/__visit + i32.const 2272 + call $~lib/rt/itcms/__visit + global.get $assembly/instructions/INSTRUCTIONS + local.tee $0 + if + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $0 + if + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $0 + if + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_PAGE + local.tee $0 + if + local.get $0 + call $~lib/rt/itcms/__visit + end + i32.const 15344 + call $~lib/rt/itcms/__visit + i32.const 15264 + call $~lib/rt/itcms/__visit + global.get $~lib/rt/itcms/pinSpace + local.tee $1 + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + loop $while-continue|0 + local.get $0 + local.get $1 + i32.ne + if + local.get $0 + i32.load offset=4 + i32.const 3 + i32.and + i32.const 3 + i32.ne + if + i32.const 0 + i32.const 1376 + i32.const 160 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.const 20 + i32.add + call $~lib/rt/__visit_members + local.get $0 + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + br $while-continue|0 + end + end + ) + (func $~lib/rt/itcms/Object#unlink (param $0 i32) + (local $1 i32) + local.get $0 + i32.load offset=4 + i32.const -4 + i32.and + local.tee $1 + i32.eqz + if + local.get $0 + i32.load offset=8 + i32.eqz + local.get $0 + i32.const 54068 + i32.lt_u + i32.and + i32.eqz + if + i32.const 0 + i32.const 1376 + i32.const 128 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + return + end + local.get $0 + i32.load offset=8 + local.tee $0 + i32.eqz + if + i32.const 0 + i32.const 1376 + i32.const 132 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $1 + local.get $0 + i32.store offset=8 + local.get $0 + local.get $1 + local.get $0 + i32.load offset=4 + i32.const 3 + i32.and + i32.or + i32.store offset=4 + ) + (func $~lib/rt/itcms/Object#makeGray (param $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + local.get $0 + global.get $~lib/rt/itcms/iter + i32.eq + if + local.get $0 + i32.load offset=8 + local.tee $1 + i32.eqz + if + i32.const 0 + i32.const 1376 + i32.const 148 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $1 + global.set $~lib/rt/itcms/iter + end + local.get $0 + call $~lib/rt/itcms/Object#unlink + global.get $~lib/rt/itcms/toSpace + local.set $1 + local.get $0 + i32.load offset=12 + local.tee $2 + i32.const 2 + i32.le_u + if (result i32) + i32.const 1 + else + local.get $2 + i32.const 21056 + i32.load + i32.gt_u + if + i32.const 1504 + i32.const 1568 + i32.const 21 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $2 + i32.const 2 + i32.shl + i32.const 21060 + i32.add + i32.load + i32.const 32 + i32.and + end + local.set $3 + local.get $1 + i32.load offset=8 + local.set $2 + local.get $0 + global.get $~lib/rt/itcms/white + i32.eqz + i32.const 2 + local.get $3 + select + local.get $1 + i32.or + i32.store offset=4 + local.get $0 + local.get $2 + i32.store offset=8 + local.get $2 + local.get $0 + local.get $2 + i32.load offset=4 + i32.const 3 + i32.and + i32.or + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=8 + ) + (func $~lib/rt/itcms/__visit (param $0 i32) + local.get $0 + i32.eqz + if + return + end + global.get $~lib/rt/itcms/white + local.get $0 + i32.const 20 + i32.sub + local.tee $0 + i32.load offset=4 + i32.const 3 + i32.and + i32.eq + if + local.get $0 + call $~lib/rt/itcms/Object#makeGray + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.add + global.set $~lib/rt/itcms/visitCount + end + ) + (func $~lib/rt/tlsf/removeBlock (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + local.get $1 + i32.load + local.tee $3 + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 268 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.const -4 + i32.and + local.tee $3 + i32.const 12 + i32.lt_u + if + i32.const 0 + i32.const 1648 + i32.const 270 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.const 256 + i32.lt_u + if (result i32) + local.get $3 + i32.const 4 + i32.shr_u + else + i32.const 31 + i32.const 1073741820 + local.get $3 + local.get $3 + i32.const 1073741820 + i32.ge_u + select + local.tee $3 + i32.clz + i32.sub + local.tee $4 + i32.const 7 + i32.sub + local.set $2 + local.get $3 + local.get $4 + i32.const 4 + i32.sub + i32.shr_u + i32.const 16 + i32.xor + end + local.tee $3 + i32.const 16 + i32.lt_u + local.get $2 + i32.const 23 + i32.lt_u + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 284 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.load offset=8 + local.set $5 + local.get $1 + i32.load offset=4 + local.tee $4 + if + local.get $4 + local.get $5 + i32.store offset=8 + end + local.get $5 + if + local.get $5 + local.get $4 + i32.store offset=4 + end + local.get $1 + local.get $0 + local.get $2 + i32.const 4 + i32.shl + local.get $3 + i32.add + i32.const 2 + i32.shl + i32.add + local.tee $1 + i32.load offset=96 + i32.eq + if + local.get $1 + local.get $5 + i32.store offset=96 + local.get $5 + i32.eqz + if + local.get $0 + local.get $2 + i32.const 2 + i32.shl + i32.add + local.tee $1 + i32.load offset=4 + i32.const -2 + local.get $3 + i32.rotl + i32.and + local.set $3 + local.get $1 + local.get $3 + i32.store offset=4 + local.get $3 + i32.eqz + if + local.get $0 + local.get $0 + i32.load + i32.const -2 + local.get $2 + i32.rotl + i32.and + i32.store + end + end + end + ) + (func $~lib/rt/tlsf/insertBlock (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + local.get $1 + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 201 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.load + local.tee $3 + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 203 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.const 4 + i32.add + local.get $1 + i32.load + i32.const -4 + i32.and + i32.add + local.tee $4 + i32.load + local.tee $2 + i32.const 1 + i32.and + if + local.get $0 + local.get $4 + call $~lib/rt/tlsf/removeBlock + local.get $1 + local.get $3 + i32.const 4 + i32.add + local.get $2 + i32.const -4 + i32.and + i32.add + local.tee $3 + i32.store + local.get $1 + i32.const 4 + i32.add + local.get $1 + i32.load + i32.const -4 + i32.and + i32.add + local.tee $4 + i32.load + local.set $2 + end + local.get $3 + i32.const 2 + i32.and + if + local.get $1 + i32.const 4 + i32.sub + i32.load + local.tee $1 + i32.load + local.tee $6 + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 221 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + call $~lib/rt/tlsf/removeBlock + local.get $1 + local.get $6 + i32.const 4 + i32.add + local.get $3 + i32.const -4 + i32.and + i32.add + local.tee $3 + i32.store + end + local.get $4 + local.get $2 + i32.const 2 + i32.or + i32.store + local.get $3 + i32.const -4 + i32.and + local.tee $2 + i32.const 12 + i32.lt_u + if + i32.const 0 + i32.const 1648 + i32.const 233 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $4 + local.get $1 + i32.const 4 + i32.add + local.get $2 + i32.add + i32.ne + if + i32.const 0 + i32.const 1648 + i32.const 234 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $4 + i32.const 4 + i32.sub + local.get $1 + i32.store + local.get $2 + i32.const 256 + i32.lt_u + if (result i32) + local.get $2 + i32.const 4 + i32.shr_u + else + i32.const 31 + i32.const 1073741820 + local.get $2 + local.get $2 + i32.const 1073741820 + i32.ge_u + select + local.tee $2 + i32.clz + i32.sub + local.tee $3 + i32.const 7 + i32.sub + local.set $5 + local.get $2 + local.get $3 + i32.const 4 + i32.sub + i32.shr_u + i32.const 16 + i32.xor + end + local.tee $2 + i32.const 16 + i32.lt_u + local.get $5 + i32.const 23 + i32.lt_u + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 251 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $5 + i32.const 4 + i32.shl + local.get $2 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + local.set $3 + local.get $1 + i32.const 0 + i32.store offset=4 + local.get $1 + local.get $3 + i32.store offset=8 + local.get $3 + if + local.get $3 + local.get $1 + i32.store offset=4 + end + local.get $0 + local.get $5 + i32.const 4 + i32.shl + local.get $2 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $1 + i32.store offset=96 + local.get $0 + local.get $0 + i32.load + i32.const 1 + local.get $5 + i32.shl + i32.or + i32.store + local.get $0 + local.get $5 + i32.const 2 + i32.shl + i32.add + local.tee $0 + local.get $0 + i32.load offset=4 + i32.const 1 + local.get $2 + i32.shl + i32.or + i32.store offset=4 + ) + (func $~lib/rt/tlsf/addMemory (param $0 i32) (param $1 i32) (param $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + local.get $2 + local.get $1 + i64.extend_i32_u + i64.lt_u + if + i32.const 0 + i32.const 1648 + i32.const 382 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.const 19 + i32.add + i32.const -16 + i32.and + i32.const 4 + i32.sub + local.set $1 + local.get $0 + i32.load offset=1568 + local.tee $3 + if + local.get $3 + i32.const 4 + i32.add + local.get $1 + i32.gt_u + if + i32.const 0 + i32.const 1648 + i32.const 389 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $3 + local.get $1 + i32.const 16 + i32.sub + local.tee $5 + i32.eq + if + local.get $3 + i32.load + local.set $4 + local.get $5 + local.set $1 + end + else + local.get $0 + i32.const 1572 + i32.add + local.get $1 + i32.gt_u + if + i32.const 0 + i32.const 1648 + i32.const 402 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + end + local.get $2 + i32.wrap_i64 + i32.const -16 + i32.and + local.get $1 + i32.sub + local.tee $3 + i32.const 20 + i32.lt_u + if + return + end + local.get $1 + local.get $4 + i32.const 2 + i32.and + local.get $3 + i32.const 8 + i32.sub + local.tee $3 + i32.const 1 + i32.or + i32.or + i32.store + local.get $1 + i32.const 0 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=8 + local.get $1 + i32.const 4 + i32.add + local.get $3 + i32.add + local.tee $3 + i32.const 2 + i32.store + local.get $0 + local.get $3 + i32.store offset=1568 + local.get $0 + local.get $1 + call $~lib/rt/tlsf/insertBlock + ) + (func $~lib/rt/tlsf/initialize + (local $0 i32) + (local $1 i32) + memory.size + local.tee $1 + i32.const 0 + i32.le_s + if (result i32) + i32.const 1 + local.get $1 + i32.sub + memory.grow + i32.const 0 + i32.lt_s + else + i32.const 0 + end + if + unreachable + end + i32.const 54080 + i32.const 0 + i32.store + i32.const 55648 + i32.const 0 + i32.store + loop $for-loop|0 + local.get $0 + i32.const 23 + i32.lt_u + if + local.get $0 + i32.const 2 + i32.shl + i32.const 54080 + i32.add + i32.const 0 + i32.store offset=4 + i32.const 0 + local.set $1 + loop $for-loop|1 + local.get $1 + i32.const 16 + i32.lt_u + if + local.get $0 + i32.const 4 + i32.shl + local.get $1 + i32.add + i32.const 2 + i32.shl + i32.const 54080 + i32.add + i32.const 0 + i32.store offset=96 + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|1 + end + end + local.get $0 + i32.const 1 + i32.add + local.set $0 + br $for-loop|0 + end + end + i32.const 54080 + i32.const 55652 + memory.size + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + i32.const 54080 + global.set $~lib/rt/tlsf/ROOT + ) + (func $~lib/rt/itcms/step (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i32) + block $break|0 + block $case2|0 + block $case1|0 + block $case0|0 + global.get $~lib/rt/itcms/state + br_table $case0|0 $case1|0 $case2|0 $break|0 + end + i32.const 1 + global.set $~lib/rt/itcms/state + i32.const 0 + global.set $~lib/rt/itcms/visitCount + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/iter + global.get $~lib/rt/itcms/visitCount + return + end + global.get $~lib/rt/itcms/white + i32.eqz + local.set $1 + global.get $~lib/rt/itcms/iter + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + loop $while-continue|1 + local.get $0 + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $0 + global.set $~lib/rt/itcms/iter + local.get $1 + local.get $0 + i32.load offset=4 + local.tee $2 + i32.const 3 + i32.and + i32.ne + if + local.get $0 + local.get $2 + i32.const -4 + i32.and + local.get $1 + i32.or + i32.store offset=4 + i32.const 0 + global.set $~lib/rt/itcms/visitCount + local.get $0 + i32.const 20 + i32.add + call $~lib/rt/__visit_members + global.get $~lib/rt/itcms/visitCount + return + end + local.get $0 + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + br $while-continue|1 + end + end + i32.const 0 + global.set $~lib/rt/itcms/visitCount + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/iter + i32.load offset=4 + i32.const -4 + i32.and + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.set $0 + loop $while-continue|0 + local.get $0 + i32.const 54068 + i32.lt_u + if + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + local.get $0 + i32.const 4 + i32.add + local.set $0 + br $while-continue|0 + end + end + global.get $~lib/rt/itcms/iter + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + loop $while-continue|2 + local.get $0 + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $1 + local.get $0 + i32.load offset=4 + local.tee $2 + i32.const 3 + i32.and + i32.ne + if + local.get $0 + local.get $2 + i32.const -4 + i32.and + local.get $1 + i32.or + i32.store offset=4 + local.get $0 + i32.const 20 + i32.add + call $~lib/rt/__visit_members + end + local.get $0 + i32.load offset=4 + i32.const -4 + i32.and + local.set $0 + br $while-continue|2 + end + end + global.get $~lib/rt/itcms/fromSpace + local.set $0 + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/fromSpace + local.get $0 + global.set $~lib/rt/itcms/toSpace + local.get $1 + global.set $~lib/rt/itcms/white + local.get $0 + i32.load offset=4 + i32.const -4 + i32.and + global.set $~lib/rt/itcms/iter + i32.const 2 + global.set $~lib/rt/itcms/state + end + global.get $~lib/rt/itcms/visitCount + return + end + global.get $~lib/rt/itcms/iter + local.tee $0 + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $0 + i32.load offset=4 + local.tee $1 + i32.const -4 + i32.and + global.set $~lib/rt/itcms/iter + global.get $~lib/rt/itcms/white + i32.eqz + local.get $1 + i32.const 3 + i32.and + i32.ne + if + i32.const 0 + i32.const 1376 + i32.const 229 + i32.const 20 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.const 54068 + i32.lt_u + if + local.get $0 + i32.const 0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=8 + else + global.get $~lib/rt/itcms/total + local.get $0 + i32.load + i32.const -4 + i32.and + i32.const 4 + i32.add + i32.sub + global.set $~lib/rt/itcms/total + local.get $0 + i32.const 4 + i32.add + local.tee $0 + i32.const 54068 + i32.ge_u + if + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $0 + i32.const 4 + i32.sub + local.set $2 + local.get $0 + i32.const 15 + i32.and + i32.const 1 + local.get $0 + select + if (result i32) + i32.const 1 + else + local.get $2 + i32.load + i32.const 1 + i32.and + end + if + i32.const 0 + i32.const 1648 + i32.const 562 + i32.const 3 + call $~lib/builtins/abort + unreachable + end + local.get $2 + local.get $2 + i32.load + i32.const 1 + i32.or + i32.store + local.get $2 + call $~lib/rt/tlsf/insertBlock + end + end + i32.const 10 + return + end + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + i32.store offset=4 + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + i32.store offset=8 + i32.const 0 + global.set $~lib/rt/itcms/state + end + i32.const 0 + ) + (func $~lib/rt/tlsf/searchBlock (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + local.get $1 + i32.const 256 + i32.lt_u + if + local.get $1 + i32.const 4 + i32.shr_u + local.set $1 + else + local.get $1 + i32.const 536870910 + i32.lt_u + if + local.get $1 + i32.const 1 + i32.const 27 + local.get $1 + i32.clz + i32.sub + i32.shl + i32.add + i32.const 1 + i32.sub + local.set $1 + end + local.get $1 + i32.const 31 + local.get $1 + i32.clz + i32.sub + local.tee $2 + i32.const 4 + i32.sub + i32.shr_u + i32.const 16 + i32.xor + local.set $1 + local.get $2 + i32.const 7 + i32.sub + local.set $2 + end + local.get $1 + i32.const 16 + i32.lt_u + local.get $2 + i32.const 23 + i32.lt_u + i32.and + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 334 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $2 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + i32.const -1 + local.get $1 + i32.shl + i32.and + local.tee $1 + if (result i32) + local.get $0 + local.get $1 + i32.ctz + local.get $2 + i32.const 4 + i32.shl + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + else + local.get $0 + i32.load + i32.const -1 + local.get $2 + i32.const 1 + i32.add + i32.shl + i32.and + local.tee $1 + if (result i32) + local.get $0 + local.get $1 + i32.ctz + local.tee $1 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + local.tee $2 + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 347 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $2 + i32.ctz + local.get $1 + i32.const 4 + i32.shl + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + else + i32.const 0 + end + end + ) + (func $~lib/rt/tlsf/allocateBlock (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + local.get $1 + i32.const 1073741820 + i32.gt_u + if + i32.const 1312 + i32.const 1648 + i32.const 461 + i32.const 29 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 12 + i32.le_u + if (result i32) + i32.const 12 + else + local.get $1 + i32.const 19 + i32.add + i32.const -16 + i32.and + i32.const 4 + i32.sub + end + local.tee $3 + call $~lib/rt/tlsf/searchBlock + local.tee $1 + i32.eqz + if + memory.size + local.tee $1 + local.get $3 + i32.const 256 + i32.ge_u + if (result i32) + local.get $3 + i32.const 536870910 + i32.lt_u + if (result i32) + local.get $3 + i32.const 1 + i32.const 27 + local.get $3 + i32.clz + i32.sub + i32.shl + i32.add + i32.const 1 + i32.sub + else + local.get $3 + end + else + local.get $3 + end + i32.const 4 + local.get $0 + i32.load offset=1568 + local.get $1 + i32.const 16 + i32.shl + i32.const 4 + i32.sub + i32.ne + i32.shl + i32.add + i32.const 65535 + i32.add + i32.const -65536 + i32.and + i32.const 16 + i32.shr_u + local.tee $2 + local.get $1 + local.get $2 + i32.gt_s + select + memory.grow + i32.const 0 + i32.lt_s + if + local.get $2 + memory.grow + i32.const 0 + i32.lt_s + if + unreachable + end + end + local.get $0 + local.get $1 + i32.const 16 + i32.shl + memory.size + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + local.get $0 + local.get $3 + call $~lib/rt/tlsf/searchBlock + local.tee $1 + i32.eqz + if + i32.const 0 + i32.const 1648 + i32.const 499 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + end + local.get $3 + local.get $1 + i32.load + i32.const -4 + i32.and + i32.gt_u + if + i32.const 0 + i32.const 1648 + i32.const 501 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + call $~lib/rt/tlsf/removeBlock + local.get $1 + i32.load + local.set $4 + local.get $3 + i32.const 4 + i32.add + i32.const 15 + i32.and + if + i32.const 0 + i32.const 1648 + i32.const 361 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $4 + i32.const -4 + i32.and + local.get $3 + i32.sub + local.tee $2 + i32.const 16 + i32.ge_u + if + local.get $1 + local.get $3 + local.get $4 + i32.const 2 + i32.and + i32.or + i32.store + local.get $1 + i32.const 4 + i32.add + local.get $3 + i32.add + local.tee $3 + local.get $2 + i32.const 4 + i32.sub + i32.const 1 + i32.or + i32.store + local.get $0 + local.get $3 + call $~lib/rt/tlsf/insertBlock + else + local.get $1 + local.get $4 + i32.const -2 + i32.and + i32.store + local.get $1 + i32.const 4 + i32.add + local.get $1 + i32.load + i32.const -4 + i32.and + i32.add + local.tee $0 + local.get $0 + i32.load + i32.const -3 + i32.and + i32.store + end + local.get $1 + ) + (func $~lib/rt/itcms/__new (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + local.get $0 + i32.const 1073741804 + i32.ge_u + if + i32.const 1312 + i32.const 1376 + i32.const 261 + i32.const 31 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.ge_u + if + block $__inlined_func$~lib/rt/itcms/interrupt$69 + i32.const 2048 + local.set $2 + loop $do-loop|0 + local.get $2 + call $~lib/rt/itcms/step + i32.sub + local.set $2 + global.get $~lib/rt/itcms/state + i32.eqz + if + global.get $~lib/rt/itcms/total + i64.extend_i32_u + i64.const 200 + i64.mul + i64.const 100 + i64.div_u + i32.wrap_i64 + i32.const 1024 + i32.add + global.set $~lib/rt/itcms/threshold + br $__inlined_func$~lib/rt/itcms/interrupt$69 + end + local.get $2 + i32.const 0 + i32.gt_s + br_if $do-loop|0 + end + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.sub + i32.const 1024 + i32.lt_u + i32.const 10 + i32.shl + i32.add + global.set $~lib/rt/itcms/threshold + end + end + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $0 + i32.const 16 + i32.add + call $~lib/rt/tlsf/allocateBlock + local.tee $2 + local.get $1 + i32.store offset=12 + local.get $2 + local.get $0 + i32.store offset=16 + global.get $~lib/rt/itcms/fromSpace + local.tee $1 + i32.load offset=8 + local.set $3 + local.get $2 + local.get $1 + global.get $~lib/rt/itcms/white + i32.or + i32.store offset=4 + local.get $2 + local.get $3 + i32.store offset=8 + local.get $3 + local.get $2 + local.get $3 + i32.load offset=4 + i32.const 3 + i32.and + i32.or + i32.store offset=4 + local.get $1 + local.get $2 + i32.store offset=8 + global.get $~lib/rt/itcms/total + local.get $2 + i32.load + i32.const -4 + i32.and + i32.const 4 + i32.add + i32.add + global.set $~lib/rt/itcms/total + local.get $2 + i32.const 20 + i32.add + local.tee $1 + i32.const 0 + local.get $0 + memory.fill + local.get $1 + ) + (func $start:assembly/arguments~anonymous|0 (param $0 i32) (param $1 i32) (result i32) + i32.const 0 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + ) + (func $~lib/rt/itcms/__link (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + local.get $1 + i32.eqz + if + return + end + local.get $0 + i32.eqz + if + i32.const 0 + i32.const 1376 + i32.const 295 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/white + local.get $1 + i32.const 20 + i32.sub + local.tee $1 + i32.load offset=4 + i32.const 3 + i32.and + i32.eq + if + local.get $0 + i32.const 20 + i32.sub + local.tee $0 + i32.load offset=4 + i32.const 3 + i32.and + local.tee $3 + global.get $~lib/rt/itcms/white + i32.eqz + i32.eq + if + local.get $0 + local.get $1 + local.get $2 + select + call $~lib/rt/itcms/Object#makeGray + else + global.get $~lib/rt/itcms/state + i32.const 1 + i32.eq + local.get $3 + i32.const 3 + i32.eq + i32.and + if + local.get $1 + call $~lib/rt/itcms/Object#makeGray + end + end + end + ) + (func $assembly/instructions/instruction (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + i32.const 17 + call $~lib/rt/tlsf/allocateBlock + i32.const 4 + i32.add + local.tee $3 + i32.const 0 + i32.store + local.get $3 + i32.const 0 + i32.store offset=4 + local.get $3 + i64.const 0 + i64.store offset=8 + local.get $3 + i32.const 0 + i32.store8 offset=16 + local.get $3 + local.get $0 + i32.store + local.get $3 + local.get $1 + i32.store offset=4 + local.get $3 + i64.const 1 + i64.store offset=8 + local.get $3 + local.get $2 + i32.store8 offset=16 + local.get $3 + ) + (func $start:assembly/instructions/misc~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $start:assembly/instructions/misc~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + call $assembly/instructions/outcome/OutcomeData#constructor + ) + (func $~lib/util/number/utoa32_dec_lut (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + loop $while-continue|0 + local.get $1 + i32.const 10000 + i32.ge_u + if + local.get $1 + i32.const 10000 + i32.rem_u + local.set $3 + local.get $1 + i32.const 10000 + i32.div_u + local.set $1 + local.get $0 + local.get $2 + i32.const 4 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $3 + i32.const 100 + i32.div_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + local.get $3 + i32.const 100 + i32.rem_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $1 + i32.const 100 + i32.ge_u + if + local.get $0 + local.get $2 + i32.const 2 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $1 + i32.const 100 + i32.rem_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i32.load + i32.store + local.get $1 + i32.const 100 + i32.div_u + local.set $1 + end + local.get $1 + i32.const 10 + i32.ge_u + if + local.get $0 + local.get $2 + i32.const 2 + i32.sub + i32.const 1 + i32.shl + i32.add + local.get $1 + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i32.load + i32.store + else + local.get $0 + local.get $2 + i32.const 1 + i32.sub + i32.const 1 + i32.shl + i32.add + local.get $1 + i32.const 48 + i32.add + i32.store16 + end + ) + (func $~lib/util/number/utoa64_any_core (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) + (local $4 i64) + (local $5 i64) + local.get $3 + i64.extend_i32_s + local.set $5 + local.get $3 + local.get $3 + i32.const 1 + i32.sub + i32.and + if + loop $do-loop|1 + local.get $0 + local.get $2 + i32.const 1 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $1 + local.get $1 + local.get $5 + i64.div_u + local.tee $1 + local.get $5 + i64.mul + i64.sub + i32.wrap_i64 + i32.const 1 + i32.shl + i32.const 17312 + i32.add + i32.load16_u + i32.store16 + local.get $1 + i64.const 0 + i64.ne + br_if $do-loop|1 + end + else + local.get $3 + i32.ctz + i32.const 7 + i32.and + i64.extend_i32_s + local.set $4 + local.get $5 + i64.const 1 + i64.sub + local.set $5 + loop $do-loop|0 + local.get $0 + local.get $2 + i32.const 1 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $1 + local.get $5 + i64.and + i32.wrap_i64 + i32.const 1 + i32.shl + i32.const 17312 + i32.add + i32.load16_u + i32.store16 + local.get $1 + local.get $4 + i64.shr_u + local.tee $1 + i64.const 0 + i64.ne + br_if $do-loop|0 + end + end + ) + (func $~lib/number/I32#toString (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $__inlined_func$~lib/util/number/itoa32$98 + local.get $0 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15824 + local.set $0 + br $__inlined_func$~lib/util/number/itoa32$98 + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $0 + i32.sub + local.get $0 + local.get $0 + i32.const 31 + i32.shr_u + i32.const 1 + i32.shl + local.tee $1 + select + local.tee $3 + i32.const 100000 + i32.lt_u + if (result i32) + local.get $3 + i32.const 100 + i32.lt_u + if (result i32) + local.get $3 + i32.const 10 + i32.ge_u + i32.const 1 + i32.add + else + local.get $3 + i32.const 10000 + i32.ge_u + i32.const 3 + i32.add + local.get $3 + i32.const 1000 + i32.ge_u + i32.add + end + else + local.get $3 + i32.const 10000000 + i32.lt_u + if (result i32) + local.get $3 + i32.const 1000000 + i32.ge_u + i32.const 6 + i32.add + else + local.get $3 + i32.const 1000000000 + i32.ge_u + i32.const 8 + i32.add + local.get $3 + i32.const 100000000 + i32.ge_u + i32.add + end + end + local.tee $2 + i32.const 1 + i32.shl + local.get $1 + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + local.get $0 + local.get $1 + i32.add + local.get $3 + local.get $2 + call $~lib/util/number/utoa32_dec_lut + local.get $1 + if + local.get $0 + i32.const 45 + i32.store16 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + end + local.get $0 + ) + (func $~lib/util/number/utoa64_dec_lut (param $0 i32) (param $1 i64) (param $2 i32) + (local $3 i32) + (local $4 i32) + loop $while-continue|0 + local.get $1 + i64.const 100000000 + i64.ge_u + if + local.get $0 + local.get $2 + i32.const 4 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $1 + local.get $1 + i64.const 100000000 + i64.div_u + local.tee $1 + i64.const 100000000 + i64.mul + i64.sub + i32.wrap_i64 + local.tee $3 + i32.const 10000 + i32.rem_u + local.tee $4 + i32.const 100 + i32.div_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + local.get $4 + i32.const 100 + i32.rem_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + i64.const 32 + i64.shl + i64.or + i64.store + local.get $0 + local.get $2 + i32.const 4 + i32.sub + local.tee $2 + i32.const 1 + i32.shl + i32.add + local.get $3 + i32.const 10000 + i32.div_u + local.tee $3 + i32.const 100 + i32.div_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + local.get $3 + i32.const 100 + i32.rem_u + i32.const 2 + i32.shl + i32.const 15836 + i32.add + i64.load32_u + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $0 + local.get $1 + i32.wrap_i64 + local.get $2 + call $~lib/util/number/utoa32_dec_lut + ) + (func $~lib/util/number/itoa_buffered (param $0 i32) (param $1 i64) (result i32) + (local $2 i32) + (local $3 i32) + local.get $0 + local.set $2 + local.get $1 + i64.const 10 + i64.lt_u + if + local.get $0 + local.get $1 + i64.const 48 + i64.or + i64.store16 + i32.const 1 + return + end + local.get $1 + i64.const 4294967295 + i64.le_u + if + local.get $1 + i32.wrap_i64 + local.tee $3 + i32.const 100000 + i32.lt_u + if (result i32) + local.get $3 + i32.const 100 + i32.lt_u + if (result i32) + local.get $3 + i32.const 10 + i32.ge_u + i32.const 1 + i32.add + else + local.get $3 + i32.const 10000 + i32.ge_u + i32.const 3 + i32.add + local.get $3 + i32.const 1000 + i32.ge_u + i32.add + end + else + local.get $3 + i32.const 10000000 + i32.lt_u + if (result i32) + local.get $3 + i32.const 1000000 + i32.ge_u + i32.const 6 + i32.add + else + local.get $3 + i32.const 1000000000 + i32.ge_u + i32.const 8 + i32.add + local.get $3 + i32.const 100000000 + i32.ge_u + i32.add + end + end + local.set $0 + local.get $2 + local.get $3 + local.get $0 + call $~lib/util/number/utoa32_dec_lut + else + local.get $2 + local.get $1 + local.get $1 + i64.const 1000000000000000 + i64.lt_u + if (result i32) + local.get $1 + i64.const 1000000000000 + i64.lt_u + if (result i32) + local.get $1 + i64.const 100000000000 + i64.ge_u + i32.const 10 + i32.add + local.get $1 + i64.const 10000000000 + i64.ge_u + i32.add + else + local.get $1 + i64.const 100000000000000 + i64.ge_u + i32.const 13 + i32.add + local.get $1 + i64.const 10000000000000 + i64.ge_u + i32.add + end + else + local.get $1 + i64.const 100000000000000000 + i64.lt_u + if (result i32) + local.get $1 + i64.const 10000000000000000 + i64.ge_u + i32.const 16 + i32.add + else + local.get $1 + i64.const -8446744073709551616 + i64.ge_u + i32.const 18 + i32.add + local.get $1 + i64.const 1000000000000000000 + i64.ge_u + i32.add + end + end + local.tee $0 + call $~lib/util/number/utoa64_dec_lut + end + local.get $0 + ) + (func $~lib/rt/itcms/__pin (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + local.get $0 + if + local.get $0 + i32.const 20 + i32.sub + local.tee $1 + i32.load offset=4 + i32.const 3 + i32.and + i32.const 3 + i32.eq + if + i32.const 20944 + i32.const 1376 + i32.const 338 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $1 + call $~lib/rt/itcms/Object#unlink + global.get $~lib/rt/itcms/pinSpace + local.tee $3 + i32.load offset=8 + local.set $2 + local.get $1 + local.get $3 + i32.const 3 + i32.or + i32.store offset=4 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $2 + local.get $1 + local.get $2 + i32.load offset=4 + i32.const 3 + i32.and + i32.or + i32.store offset=4 + local.get $3 + local.get $1 + i32.store offset=8 + end + local.get $0 + ) + (func $~lib/rt/itcms/__unpin (param $0 i32) + (local $1 i32) + (local $2 i32) + local.get $0 + i32.eqz + if + return + end + local.get $0 + i32.const 20 + i32.sub + local.tee $1 + i32.load offset=4 + i32.const 3 + i32.and + i32.const 3 + i32.ne + if + i32.const 21008 + i32.const 1376 + i32.const 352 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/state + i32.const 1 + i32.eq + if + local.get $1 + call $~lib/rt/itcms/Object#makeGray + else + local.get $1 + call $~lib/rt/itcms/Object#unlink + global.get $~lib/rt/itcms/fromSpace + local.tee $0 + i32.load offset=8 + local.set $2 + local.get $1 + local.get $0 + global.get $~lib/rt/itcms/white + i32.or + i32.store offset=4 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $2 + local.get $1 + local.get $2 + i32.load offset=4 + i32.const 3 + i32.and + i32.or + i32.store offset=4 + local.get $0 + local.get $1 + i32.store offset=8 + end + ) + (func $~lib/rt/itcms/__collect + global.get $~lib/rt/itcms/state + i32.const 0 + i32.gt_s + if + loop $while-continue|0 + global.get $~lib/rt/itcms/state + if + call $~lib/rt/itcms/step + drop + br $while-continue|0 + end + end + end + call $~lib/rt/itcms/step + drop + loop $while-continue|1 + global.get $~lib/rt/itcms/state + if + call $~lib/rt/itcms/step + drop + br $while-continue|1 + end + end + global.get $~lib/rt/itcms/total + i64.extend_i32_u + i64.const 200 + i64.mul + i64.const 100 + i64.div_u + i32.wrap_i64 + i32.const 1024 + i32.add + global.set $~lib/rt/itcms/threshold + ) + (func $assembly/gas/GasCounter#set@override (param $0 i32) (param $1 i64) + local.get $0 + i32.const 8 + i32.sub + i32.load + i32.const 51 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + unreachable + ) + (func $assembly/gas/GasCounter#sub@override (param $0 i32) (param $1 i64) (result i32) + local.get $0 + i32.const 8 + i32.sub + i32.load + i32.const 51 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i64.load + local.get $1 + i64.sub + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load + i64.const 0 + i64.lt_s + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + unreachable + ) + (func $assembly/gas/GasCounter#get@override (param $0 i32) (result i64) + (local $1 i64) + local.get $0 + i32.const 8 + i32.sub + i32.load + i32.const 51 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + unreachable + ) + (func $assembly/interpreter/Interpreter~visit (param $0 i32) + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + call $~lib/rt/itcms/__visit + ) + (func $~lib/rt/__visit_members (param $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + block $folding-inner9 + block $folding-inner8 + block $folding-inner7 + block $folding-inner6 + block $folding-inner5 + block $folding-inner4 + block $folding-inner3 + block $folding-inner2 + block $folding-inner1 + block $folding-inner0 + block $invalid + block $~lib/staticarray/StaticArray + block $assembly/interpreter/BranchResult + block $assembly/interpreter/DjumpResult + block $assembly/program/ResolvedArguments + block $assembly/gas/GasCounterU64 + block $assembly/api-generic/InitialPage + block $assembly/api-generic/VmInput + block $assembly/api-generic/VmOutput + block $assembly/codec/ValOffset + block $~lib/staticarray/StaticArray<~lib/string/String> + block $assembly/gas/GasCounter + block $~lib/staticarray/StaticArray + block $~lib/staticarray/StaticArray + block $assembly/program/Program + block $assembly/interpreter/Interpreter + block $assembly/memory/Chunks + block $~lib/staticarray/StaticArray + block $assembly/memory/Result + block $assembly/instructions/outcome/OutcomeData + block $"~lib/map/Map" + block $~lib/staticarray/StaticArray + block $assembly/memory/MaybePageFault + block $assembly/arguments/Nibbles + block $assembly/arguments/Args + block $~lib/string/String + block $~lib/arraybuffer/ArrayBuffer + block $~lib/object/Object + local.get $0 + i32.const 8 + i32.sub + i32.load + br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $folding-inner0 $folding-inner1 $folding-inner0 $assembly/arguments/Args $folding-inner2 $folding-inner3 $assembly/arguments/Nibbles $folding-inner1 $assembly/memory/MaybePageFault $folding-inner4 $folding-inner4 $~lib/staticarray/StaticArray $folding-inner5 $folding-inner0 $folding-inner2 $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $folding-inner3 $assembly/memory/Result $folding-inner6 $~lib/staticarray/StaticArray $assembly/memory/Chunks $folding-inner6 $folding-inner2 $folding-inner1 $folding-inner3 $assembly/interpreter/Interpreter $assembly/program/Program $folding-inner0 $~lib/staticarray/StaticArray $folding-inner0 $folding-inner0 $~lib/staticarray/StaticArray $assembly/gas/GasCounter $folding-inner6 $folding-inner0 $~lib/staticarray/StaticArray<~lib/string/String> $assembly/codec/ValOffset $folding-inner3 $folding-inner1 $folding-inner1 $assembly/api-generic/VmOutput $folding-inner4 $folding-inner2 $assembly/api-generic/VmInput $assembly/api-generic/InitialPage $folding-inner2 $folding-inner6 $assembly/gas/GasCounterU64 $folding-inner2 $folding-inner3 $assembly/program/ResolvedArguments $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $folding-inner2 $~lib/staticarray/StaticArray $folding-inner0 $invalid + end + return + end + return + end + return + end + return + end + return + end + return + end + return + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner7 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + local.tee $2 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=16 + i32.const 12 + i32.mul + i32.add + local.set $0 + loop $while-continue|0 + local.get $0 + local.get $1 + i32.gt_u + if + local.get $1 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if + local.get $1 + i32.load offset=4 + call $~lib/rt/itcms/__visit + end + local.get $1 + i32.const 12 + i32.add + local.set $1 + br $while-continue|0 + end + end + local.get $2 + call $~lib/rt/itcms/__visit + br $folding-inner9 + end + return + end + local.get $0 + i32.load offset=8 + call $~lib/rt/itcms/__visit + return + end + return + end + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + br $folding-inner5 + end + local.get $0 + call $assembly/interpreter/Interpreter~visit + return + end + local.get $0 + call $assembly/interpreter/Interpreter~visit + return + end + return + end + return + end + return + end + local.get $0 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.add + local.set $1 + loop $while-continue|01 + local.get $0 + local.get $1 + i32.lt_u + if + local.get $0 + i32.load + local.tee $2 + if + local.get $2 + call $~lib/rt/itcms/__visit + end + local.get $0 + i32.const 4 + i32.add + local.set $0 + br $while-continue|01 + end + end + return + end + return + end + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + call $~lib/rt/itcms/__visit + return + end + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=16 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=20 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=24 + call $~lib/rt/itcms/__visit + return + end + return + end + return + end + local.get $0 + i32.load offset=32 + call $~lib/rt/itcms/__visit + return + end + return + end + return + end + return + end + unreachable + end + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + return + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner7 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + br $folding-inner8 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner7 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.const 2 + i32.shl + i32.add + local.set $3 + loop $while-continue|00 + local.get $1 + local.get $3 + i32.lt_u + if + local.get $1 + i32.load + local.tee $2 + if + local.get $2 + call $~lib/rt/itcms/__visit + end + local.get $1 + i32.const 4 + i32.add + local.set $1 + br $while-continue|00 + end + end + br $folding-inner8 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner7 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + br $folding-inner9 + end + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + return + end + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + call $~lib/rt/itcms/__visit + return + end + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~setArgumentsLength (param $0 i32) + local.get $0 + global.set $~argumentsLength + ) + (func $~start + (local $0 i32) + memory.size + i32.const 16 + i32.shl + i32.const 54068 + i32.sub + i32.const 1 + i32.shr_u + global.set $~lib/rt/itcms/threshold + i32.const 1428 + i32.const 1424 + i32.store + i32.const 1432 + i32.const 1424 + i32.store + i32.const 1424 + global.set $~lib/rt/itcms/pinSpace + i32.const 1460 + i32.const 1456 + i32.store + i32.const 1464 + i32.const 1456 + i32.store + i32.const 1456 + global.set $~lib/rt/itcms/toSpace + i32.const 1604 + i32.const 1600 + i32.store + i32.const 1608 + i32.const 1600 + i32.store + i32.const 1600 + global.set $~lib/rt/itcms/fromSpace + call $start:assembly/instructions + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + call $assembly/memory/MaybePageFault#constructor + global.set $assembly/memory/NO_PAGE_FAULT + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + global.set $assembly/memory/EMPTY_UINT8ARRAY + i32.const -1 + i32.const 0 + call $assembly/memory-page/RawPage#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 0 + local.get $0 + call $assembly/memory-page/Page#constructor + global.set $assembly/memory/EMPTY_PAGE + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/arguments/Args#constructor (result i32) + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 6 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/arguments/Args.from (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/arguments/Args#constructor + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#get:length (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/typedarray/Uint8Array#subarray (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $4 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $4 + local.get $0 + i32.load + local.tee $5 + i32.store + local.get $4 + local.get $5 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $4 + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 0 + i32.lt_s + if (result i32) + local.get $1 + local.get $3 + i32.add + local.tee $0 + i32.const 0 + local.get $0 + i32.const 0 + i32.gt_s + select + else + local.get $1 + local.get $3 + local.get $1 + local.get $3 + i32.lt_s + select + end + local.tee $0 + i32.add + i32.store offset=4 + local.get $4 + local.get $2 + i32.const 0 + i32.lt_s + if (result i32) + local.get $2 + local.get $3 + i32.add + local.tee $1 + i32.const 0 + local.get $1 + i32.const 0 + i32.gt_s + select + else + local.get $2 + local.get $3 + local.get $2 + local.get $3 + i32.lt_s + select + end + local.tee $1 + local.get $0 + local.get $0 + local.get $1 + i32.lt_s + select + local.get $0 + i32.sub + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=8 + i32.ge_u + if + i32.const 1504 + i32.const 1744 + i32.const 167 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + i32.load8_u + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/arguments/decodeI32 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + local.get $2 + local.get $1 + local.get $1 + local.get $2 + i32.lt_u + select + call $~lib/typedarray/Uint8Array#subarray + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_u + local.set $2 + i32.const 0 + local.set $1 + loop $for-loop|0 + local.get $2 + local.get $3 + i32.gt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + local.get $3 + i32.const 3 + i32.shl + i32.shl + i32.or + local.set $1 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + i32.const 255 + i32.const 0 + local.get $2 + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $2 + i32.const 1 + i32.sub + call $~lib/typedarray/Uint8Array#__get + i32.const 128 + i32.and + else + i32.const 0 + end + select + local.set $0 + loop $for-loop|1 + local.get $2 + i32.const 4 + i32.lt_u + if + local.get $1 + local.get $0 + local.get $2 + i32.const 3 + i32.shl + i32.shl + i32.or + local.set $1 + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/arguments~anonymous|1 (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + local.get $1 + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/arguments/nibbles (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 2 + i32.const 9 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + call $~lib/object/Object#constructor + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store8 offset=1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.const 15 + i32.and + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.const 255 + i32.and + i32.const 4 + i32.shr_u + i32.store8 offset=1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/arguments/twoImm (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u + f64.convert_i32_u + f64.const 4 + f64.min + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + local.get $2 + call $assembly/arguments/decodeI32 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $2 + local.get $1 + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|2 (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + call $assembly/arguments/twoImm + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|4 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + local.get $1 + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/typedarray/Uint8Array#subarray@varargs (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $1 + end + i32.const 2147483647 + local.set $2 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $~lib/typedarray/Uint8Array#subarray + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/arguments/decodeU32 (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 2 + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 3 + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|5 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load8_u + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + local.get $0 + i32.const 1 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/arguments/decodeU32 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + local.get $0 + i32.const 5 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/arguments/decodeU32 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|6 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u offset=1 + f64.convert_i32_u + f64.const 4 + f64.min + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + local.get $3 + call $assembly/arguments/decodeI32 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + local.get $1 + call $assembly/arguments/decodeI32 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u + local.get $4 + local.get $0 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|8 (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u offset=1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|9 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load8_u offset=1 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load8_u + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + local.get $1 + call $assembly/arguments/decodeI32 + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|11 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 1 + global.set $~argumentsLength + local.get $0 + i32.const 1 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.const 1 + i32.sub + i32.const 0 + local.get $1 + i32.const 1 + i32.gt_u + select + call $assembly/arguments/twoImm + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u offset=1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load8_u + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/arguments~anonymous|12 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load8_u offset=1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load8_u + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u + i32.const 0 + call $assembly/arguments/Args.from + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/ensureCapacity (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=8 + local.tee $5 + local.get $2 + i32.shr_u + i32.gt_u + if + local.get $1 + i32.const 1073741820 + local.get $2 + i32.shr_u + i32.gt_u + if + i32.const 9200 + i32.const 9152 + i32.const 19 + i32.const 48 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $4 + i32.const 8 + local.get $1 + local.get $1 + i32.const 8 + i32.le_u + select + local.get $2 + i32.shl + local.set $1 + local.get $3 + if + i32.const 1073741820 + local.get $5 + i32.const 1 + i32.shl + local.tee $2 + local.get $2 + i32.const 1073741820 + i32.ge_u + select + local.tee $2 + local.get $1 + local.get $1 + local.get $2 + i32.lt_u + select + local.set $1 + end + block $__inlined_func$~lib/rt/itcms/__renew$2366 + local.get $4 + i32.const 20 + i32.sub + local.tee $3 + i32.load + i32.const -4 + i32.and + i32.const 16 + i32.sub + local.get $1 + i32.ge_u + if + local.get $3 + local.get $1 + i32.store offset=16 + local.get $4 + local.set $2 + br $__inlined_func$~lib/rt/itcms/__renew$2366 + end + local.get $1 + local.get $3 + i32.load offset=12 + call $~lib/rt/itcms/__new + local.tee $2 + local.get $4 + local.get $1 + local.get $3 + i32.load offset=16 + local.tee $3 + local.get $1 + local.get $3 + i32.lt_u + select + memory.copy + end + local.get $2 + local.get $4 + i32.ne + if + local.get $0 + local.get $2 + i32.store + local.get $0 + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + end + local.get $0 + local.get $1 + i32.store offset=8 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__set (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + local.get $1 + i32.const 0 + i32.lt_s + if + i32.const 1504 + i32.const 9152 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + i32.store offset=12 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 2320 + i32.store + i32.const 2320 + i32.const 0 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/MISSING_INSTRUCTION + global.get $~lib/memory/__stack_pointer + i32.const 2368 + i32.store + i32.const 2368 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/SBRK + global.get $~lib/memory/__stack_pointer + i32.const 231 + i32.const 2 + i32.const 10 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 2400 + i32.store + local.get $0 + i32.const 0 + i32.const 2400 + i32.const 0 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2432 + i32.store + local.get $0 + i32.const 1 + i32.const 2432 + i32.const 0 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 5 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 6 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 7 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 8 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 9 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2480 + i32.store + local.get $0 + i32.const 10 + i32.const 2480 + i32.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 11 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 12 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 13 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 14 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 15 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 16 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 17 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 18 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 19 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2512 + i32.store + local.get $0 + i32.const 20 + i32.const 2512 + i32.const 5 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 21 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 22 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 23 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 24 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 25 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 26 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 27 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 28 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 29 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2560 + i32.store + local.get $0 + i32.const 30 + i32.const 2560 + i32.const 2 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2608 + i32.store + local.get $0 + i32.const 31 + i32.const 2608 + i32.const 2 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2656 + i32.store + local.get $0 + i32.const 32 + i32.const 2656 + i32.const 2 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2704 + i32.store + local.get $0 + i32.const 33 + i32.const 2704 + i32.const 2 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 34 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 35 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 36 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 37 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 38 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 39 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2752 + i32.store + local.get $0 + i32.const 40 + i32.const 2752 + i32.const 3 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 41 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 42 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 43 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 44 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 45 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 46 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 47 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 48 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 49 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2784 + i32.store + local.get $0 + i32.const 50 + i32.const 2784 + i32.const 4 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2832 + i32.store + local.get $0 + i32.const 51 + i32.const 2832 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2880 + i32.store + local.get $0 + i32.const 52 + i32.const 2880 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2928 + i32.store + local.get $0 + i32.const 53 + i32.const 2928 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 2976 + i32.store + local.get $0 + i32.const 54 + i32.const 2976 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3024 + i32.store + local.get $0 + i32.const 55 + i32.const 3024 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3072 + i32.store + local.get $0 + i32.const 56 + i32.const 3072 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3120 + i32.store + local.get $0 + i32.const 57 + i32.const 3120 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3168 + i32.store + local.get $0 + i32.const 58 + i32.const 3168 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3216 + i32.store + local.get $0 + i32.const 59 + i32.const 3216 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3264 + i32.store + local.get $0 + i32.const 60 + i32.const 3264 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3312 + i32.store + local.get $0 + i32.const 61 + i32.const 3312 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3360 + i32.store + local.get $0 + i32.const 62 + i32.const 3360 + i32.const 4 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 63 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 64 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 65 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 66 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 67 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 68 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 69 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3408 + i32.store + local.get $0 + i32.const 70 + i32.const 3408 + i32.const 6 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3472 + i32.store + local.get $0 + i32.const 71 + i32.const 3472 + i32.const 6 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3536 + i32.store + local.get $0 + i32.const 72 + i32.const 3536 + i32.const 6 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3600 + i32.store + local.get $0 + i32.const 73 + i32.const 3600 + i32.const 6 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 74 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 75 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 76 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 77 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 78 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 79 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3664 + i32.store + local.get $0 + i32.const 80 + i32.const 3664 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3712 + i32.store + local.get $0 + i32.const 81 + i32.const 3712 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3760 + i32.store + local.get $0 + i32.const 82 + i32.const 3760 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3808 + i32.store + local.get $0 + i32.const 83 + i32.const 3808 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3872 + i32.store + local.get $0 + i32.const 84 + i32.const 3872 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 3936 + i32.store + local.get $0 + i32.const 85 + i32.const 3936 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4000 + i32.store + local.get $0 + i32.const 86 + i32.const 4000 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4064 + i32.store + local.get $0 + i32.const 87 + i32.const 4064 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4128 + i32.store + local.get $0 + i32.const 88 + i32.const 4128 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4192 + i32.store + local.get $0 + i32.const 89 + i32.const 4192 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4256 + i32.store + local.get $0 + i32.const 90 + i32.const 4256 + i32.const 7 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 91 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 92 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 93 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 94 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 95 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 96 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 97 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 98 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 99 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4320 + i32.store + local.get $0 + i32.const 100 + i32.const 4320 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 101 + global.get $assembly/instructions/SBRK + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4368 + i32.store + local.get $0 + i32.const 102 + i32.const 4368 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4432 + i32.store + local.get $0 + i32.const 103 + i32.const 4432 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4496 + i32.store + local.get $0 + i32.const 104 + i32.const 4496 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4560 + i32.store + local.get $0 + i32.const 105 + i32.const 4560 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4624 + i32.store + local.get $0 + i32.const 106 + i32.const 4624 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4688 + i32.store + local.get $0 + i32.const 107 + i32.const 4688 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4752 + i32.store + local.get $0 + i32.const 108 + i32.const 4752 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4800 + i32.store + local.get $0 + i32.const 109 + i32.const 4800 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4848 + i32.store + local.get $0 + i32.const 110 + i32.const 4848 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4896 + i32.store + local.get $0 + i32.const 111 + i32.const 4896 + i32.const 8 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 112 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 113 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 114 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 115 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 116 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 117 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 118 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 119 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4944 + i32.store + local.get $0 + i32.const 120 + i32.const 4944 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 4992 + i32.store + local.get $0 + i32.const 121 + i32.const 4992 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5040 + i32.store + local.get $0 + i32.const 122 + i32.const 5040 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5088 + i32.store + local.get $0 + i32.const 123 + i32.const 5088 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5136 + i32.store + local.get $0 + i32.const 124 + i32.const 5136 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5184 + i32.store + local.get $0 + i32.const 125 + i32.const 5184 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5232 + i32.store + local.get $0 + i32.const 126 + i32.const 5232 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5280 + i32.store + local.get $0 + i32.const 127 + i32.const 5280 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5328 + i32.store + local.get $0 + i32.const 128 + i32.const 5328 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5376 + i32.store + local.get $0 + i32.const 129 + i32.const 5376 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5424 + i32.store + local.get $0 + i32.const 130 + i32.const 5424 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5472 + i32.store + local.get $0 + i32.const 131 + i32.const 5472 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5520 + i32.store + local.get $0 + i32.const 132 + i32.const 5520 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5568 + i32.store + local.get $0 + i32.const 133 + i32.const 5568 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5616 + i32.store + local.get $0 + i32.const 134 + i32.const 5616 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5648 + i32.store + local.get $0 + i32.const 135 + i32.const 5648 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5696 + i32.store + local.get $0 + i32.const 136 + i32.const 5696 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5744 + i32.store + local.get $0 + i32.const 137 + i32.const 5744 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5792 + i32.store + local.get $0 + i32.const 138 + i32.const 5792 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5840 + i32.store + local.get $0 + i32.const 139 + i32.const 5840 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5888 + i32.store + local.get $0 + i32.const 140 + i32.const 5888 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5936 + i32.store + local.get $0 + i32.const 141 + i32.const 5936 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 5984 + i32.store + local.get $0 + i32.const 142 + i32.const 5984 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6032 + i32.store + local.get $0 + i32.const 143 + i32.const 6032 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6080 + i32.store + local.get $0 + i32.const 144 + i32.const 6080 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6144 + i32.store + local.get $0 + i32.const 145 + i32.const 6144 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6208 + i32.store + local.get $0 + i32.const 146 + i32.const 6208 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6272 + i32.store + local.get $0 + i32.const 147 + i32.const 6272 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6320 + i32.store + local.get $0 + i32.const 148 + i32.const 6320 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6368 + i32.store + local.get $0 + i32.const 149 + i32.const 6368 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6416 + i32.store + local.get $0 + i32.const 150 + i32.const 6416 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6464 + i32.store + local.get $0 + i32.const 151 + i32.const 6464 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6512 + i32.store + local.get $0 + i32.const 152 + i32.const 6512 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6560 + i32.store + local.get $0 + i32.const 153 + i32.const 6560 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6608 + i32.store + local.get $0 + i32.const 154 + i32.const 6608 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6656 + i32.store + local.get $0 + i32.const 155 + i32.const 6656 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6720 + i32.store + local.get $0 + i32.const 156 + i32.const 6720 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6784 + i32.store + local.get $0 + i32.const 157 + i32.const 6784 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6848 + i32.store + local.get $0 + i32.const 158 + i32.const 6848 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6896 + i32.store + local.get $0 + i32.const 159 + i32.const 6896 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 6960 + i32.store + local.get $0 + i32.const 160 + i32.const 6960 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7008 + i32.store + local.get $0 + i32.const 161 + i32.const 7008 + i32.const 9 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 162 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 163 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 164 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 165 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 166 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 167 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 168 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 169 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7072 + i32.store + local.get $0 + i32.const 170 + i32.const 7072 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7120 + i32.store + local.get $0 + i32.const 171 + i32.const 7120 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7168 + i32.store + local.get $0 + i32.const 172 + i32.const 7168 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7216 + i32.store + local.get $0 + i32.const 173 + i32.const 7216 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7264 + i32.store + local.get $0 + i32.const 174 + i32.const 7264 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7312 + i32.store + local.get $0 + i32.const 175 + i32.const 7312 + i32.const 10 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 176 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 177 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 178 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 179 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7360 + i32.store + local.get $0 + i32.const 180 + i32.const 7360 + i32.const 11 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 181 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 182 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 183 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 184 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 185 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 186 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 187 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 188 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 189 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7424 + i32.store + local.get $0 + i32.const 190 + i32.const 7424 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7456 + i32.store + local.get $0 + i32.const 191 + i32.const 7456 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7488 + i32.store + local.get $0 + i32.const 192 + i32.const 7488 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7520 + i32.store + local.get $0 + i32.const 193 + i32.const 7520 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7568 + i32.store + local.get $0 + i32.const 194 + i32.const 7568 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7616 + i32.store + local.get $0 + i32.const 195 + i32.const 7616 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7664 + i32.store + local.get $0 + i32.const 196 + i32.const 7664 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7712 + i32.store + local.get $0 + i32.const 197 + i32.const 7712 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7760 + i32.store + local.get $0 + i32.const 198 + i32.const 7760 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7808 + i32.store + local.get $0 + i32.const 199 + i32.const 7808 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7856 + i32.store + local.get $0 + i32.const 200 + i32.const 7856 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7888 + i32.store + local.get $0 + i32.const 201 + i32.const 7888 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7920 + i32.store + local.get $0 + i32.const 202 + i32.const 7920 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 7952 + i32.store + local.get $0 + i32.const 203 + i32.const 7952 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8000 + i32.store + local.get $0 + i32.const 204 + i32.const 8000 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8048 + i32.store + local.get $0 + i32.const 205 + i32.const 8048 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8096 + i32.store + local.get $0 + i32.const 206 + i32.const 8096 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8144 + i32.store + local.get $0 + i32.const 207 + i32.const 8144 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8192 + i32.store + local.get $0 + i32.const 208 + i32.const 8192 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8240 + i32.store + local.get $0 + i32.const 209 + i32.const 8240 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8288 + i32.store + local.get $0 + i32.const 210 + i32.const 8288 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8320 + i32.store + local.get $0 + i32.const 211 + i32.const 8320 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8352 + i32.store + local.get $0 + i32.const 212 + i32.const 8352 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8384 + i32.store + local.get $0 + i32.const 213 + i32.const 8384 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8432 + i32.store + local.get $0 + i32.const 214 + i32.const 8432 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8480 + i32.store + local.get $0 + i32.const 215 + i32.const 8480 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8528 + i32.store + local.get $0 + i32.const 216 + i32.const 8528 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8576 + i32.store + local.get $0 + i32.const 217 + i32.const 8576 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8624 + i32.store + local.get $0 + i32.const 218 + i32.const 8624 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8672 + i32.store + local.get $0 + i32.const 219 + i32.const 8672 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8720 + i32.store + local.get $0 + i32.const 220 + i32.const 8720 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8768 + i32.store + local.get $0 + i32.const 221 + i32.const 8768 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8816 + i32.store + local.get $0 + i32.const 222 + i32.const 8816 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8864 + i32.store + local.get $0 + i32.const 223 + i32.const 8864 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8912 + i32.store + local.get $0 + i32.const 224 + i32.const 8912 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8960 + i32.store + local.get $0 + i32.const 225 + i32.const 8960 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 8992 + i32.store + local.get $0 + i32.const 226 + i32.const 8992 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 9024 + i32.store + local.get $0 + i32.const 227 + i32.const 9024 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 9056 + i32.store + local.get $0 + i32.const 228 + i32.const 9056 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 9088 + i32.store + local.get $0 + i32.const 229 + i32.const 9088 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + i32.const 9120 + i32.store + local.get $0 + i32.const 230 + i32.const 9120 + i32.const 12 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/INSTRUCTIONS + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/MaybePageFault#constructor (result i32) + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 11 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store8 offset=1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/typedarray/Uint8Array#constructor (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $1 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 3 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store + local.get $1 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=8 + local.get $0 + i32.const 1073741820 + i32.gt_u + if + i32.const 9200 + i32.const 9248 + i32.const 19 + i32.const 57 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.store + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory-page/Page#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 12 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $2 + local.get $1 + i32.store offset=4 + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/memory-page/RawPage#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 13 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $2 + local.get $1 + i32.store offset=4 + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i64) + (local $2 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 3 + i32.shl + i32.add + i64.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.const 3 + i32.shl + i32.add + local.get $2 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/OutcomeData#constructor (result i32) + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.const 19 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $start:assembly/instructions/bit~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.popcnt + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.popcnt + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.clz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.clz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.ctz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.ctz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.extend8_s + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.extend16_s + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.const 65535 + i32.and + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.tee $3 + i64.const 8 + i64.shr_u + i64.const 71777214294589695 + i64.and + local.get $3 + i64.const 71777214294589695 + i64.and + i64.const 8 + i64.shl + i64.or + local.tee $3 + i64.const 16 + i64.shr_u + i64.const 281470681808895 + i64.and + local.get $3 + i64.const 281470681808895 + i64.and + i64.const 16 + i64.shl + i64.or + i64.const 32 + i64.rotr + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/staticJump (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/branch~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.ne + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $3 + i64.gt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.ge_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.ne + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.gt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/jump~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/dJump (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/jump~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.add + i32.wrap_i64 + call $assembly/instructions/outcome/dJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/jump~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=4 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + call $assembly/instructions/outcome/staticJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/jump~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=12 + i64.add + i32.wrap_i64 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/dJump + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_u offset=8 + i64.const 32 + i64.shl + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=4 + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Chunks#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 24 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $3 + local.get $0 + i32.store + local.get $3 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + i32.store offset=4 + local.get $3 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $3 + local.get $2 + i32.store offset=8 + local.get $3 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory/Chunks#constructor@varargs (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $1 + i32.store + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $2 + i32.store offset=4 + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=20 + local.get $0 + local.get $1 + local.get $2 + call $assembly/memory/Chunks#constructor + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#find" (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.load offset=4 + i32.and + i32.const 2 + i32.shl + i32.add + i32.load + local.set $0 + loop $while-continue|0 + local.get $0 + if + local.get $0 + i32.load offset=8 + local.tee $2 + i32.const 1 + i32.and + if (result i32) + i32.const 0 + else + local.get $1 + local.get $0 + i32.load + i32.eq + end + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + local.get $2 + i32.const -2 + i32.and + local.set $0 + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $"~lib/map/Map#has" (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $1 + i32.const -1028477379 + i32.mul + i32.const 374761397 + i32.add + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.tee $0 + local.get $0 + i32.const 15 + i32.shr_u + i32.xor + i32.const -2048144777 + i32.mul + local.tee $0 + local.get $0 + i32.const 13 + i32.shr_u + i32.xor + i32.const -1028477379 + i32.mul + local.tee $0 + local.get $0 + i32.const 16 + i32.shr_u + i32.xor + call $"~lib/map/Map#find" + i32.const 0 + i32.ne + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/PageData#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 25 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $3 + local.get $0 + i32.store + local.get $3 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + i32.store offset=4 + local.get $3 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory/fault (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/memory/MaybePageFault#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 1 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $"~lib/map/Map#get" (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $1 + i32.const -1028477379 + i32.mul + i32.const 374761397 + i32.add + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.tee $0 + local.get $0 + i32.const 15 + i32.shr_u + i32.xor + i32.const -2048144777 + i32.mul + local.tee $0 + local.get $0 + i32.const 13 + i32.shr_u + i32.xor + i32.const -1028477379 + i32.mul + local.tee $0 + local.get $0 + i32.const 16 + i32.shr_u + i32.xor + call $"~lib/map/Map#find" + local.tee $0 + i32.eqz + if + i32.const 10400 + i32.const 10464 + i32.const 105 + i32.const 17 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory-page/Page#can (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + i32.const 2 + i32.eq + if (result i32) + i32.const 1 + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load + i32.eq + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/typedarray/Uint8Array#fill@varargs (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $1of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 2147483647 + local.set $1 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.tee $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.le_s + select + local.tee $3 + local.get $1 + local.get $2 + local.get $1 + local.get $2 + i32.lt_s + select + local.tee $1 + i32.lt_s + if + local.get $3 + local.get $4 + i32.add + i32.const 0 + local.get $1 + local.get $3 + i32.sub + memory.fill + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory-page/RawPage#get:data (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 4096 + call $~lib/typedarray/Uint8Array#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + i32.const 1 + global.set $~argumentsLength + local.get $1 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 10640 + i32.const 42 + i32.const 12 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/memory/Memory#getChunks (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner3 (result i32) + block $folding-inner2 + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + local.get $3 + i32.const 255 + i32.and + i32.eqz + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $0 + i32.store + br $folding-inner2 + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $2 + i32.const 4095 + i32.and + local.set $5 + local.get $2 + i32.const 12 + i32.shr_u + local.tee $6 + i32.const 12 + i32.shl + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $8 + i32.store + block $__inlined_func$assembly/memory/Memory#getPage$2371 (result i32) + local.get $8 + local.get $6 + call $"~lib/map/Map#has" + i32.eqz + if + local.get $7 + call $assembly/memory/fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_PAGE + local.tee $7 + i32.store offset=4 + local.get $6 + local.get $7 + local.get $5 + call $assembly/memory/PageData#constructor + br $__inlined_func$assembly/memory/Memory#getPage$2371 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $8 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + local.get $6 + call $"~lib/map/Map#get" + local.tee $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $1 + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $7 + call $assembly/memory/fault + local.tee $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 1 + i32.store8 offset=1 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_PAGE + local.tee $7 + i32.store offset=4 + local.get $6 + local.get $7 + local.get $5 + call $assembly/memory/PageData#constructor + br $__inlined_func$assembly/memory/Memory#getPage$2371 + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $7 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $7 + local.get $6 + local.get $5 + call $assembly/memory/PageData#constructor + end + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $4 + i32.store + local.get $4 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $0 + i32.store + br $folding-inner2 + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + local.tee $4 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.load offset=8 + local.tee $5 + local.get $3 + i32.const 255 + i32.and + i32.add + local.tee $6 + i32.const 4096 + i32.le_u + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load offset=4 + local.tee $1 + i32.store offset=8 + local.get $1 + call $assembly/memory-page/RawPage#get:data + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $5 + local.get $6 + call $~lib/typedarray/Uint8Array#subarray + local.tee $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 2 + global.set $~argumentsLength + local.get $1 + local.get $0 + call $assembly/memory/Chunks#constructor@varargs + br $folding-inner3 + end + local.get $2 + local.get $3 + i32.const 255 + i32.and + i32.add + i64.extend_i32_u + i64.const 4294967295 + i64.and + i32.wrap_i64 + i32.const 12 + i32.shr_u + local.tee $2 + i32.const 12 + i32.shl + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $7 + i32.store + block $folding-inner0 + local.get $7 + local.get $2 + call $"~lib/map/Map#has" + i32.eqz + if + local.get $6 + call $assembly/memory/fault + local.set $0 + br $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $2 + call $"~lib/map/Map#get" + local.tee $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $6 + call $assembly/memory/fault + local.tee $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store8 offset=1 + br $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load offset=4 + local.tee $2 + i32.store offset=8 + local.get $2 + call $assembly/memory-page/RawPage#get:data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + i32.const 1 + global.set $~argumentsLength + local.get $2 + local.get $5 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $1 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=8 + local.get $0 + call $assembly/memory-page/RawPage#get:data + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + local.get $5 + local.get $3 + i32.const 255 + i32.and + i32.add + i32.const 4096 + i32.sub + call $~lib/typedarray/Uint8Array#subarray + local.tee $0 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + local.get $2 + local.get $1 + local.get $0 + call $assembly/memory/Chunks#constructor + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + br $folding-inner2 + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + i32.const 1 + global.set $~argumentsLength + local.get $0 + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + end + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/ChunkBytes#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 22 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $2 + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $2 + local.get $1 + i32.store offset=4 + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.add + local.get $2 + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getBytes (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 1 + local.get $1 + local.get $2 + call $assembly/memory/Memory#getChunks + local.tee $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $0 + i32.store + local.get $0 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $0 + i32.store + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $~lib/staticarray/StaticArray#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $0 + local.get $1 + call $assembly/memory/ChunkBytes#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=8 + local.tee $4 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.const 255 + i32.and + call $~lib/staticarray/StaticArray#constructor + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $6 + loop $for-loop|0 + local.get $3 + local.get $6 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $2 + local.get $3 + local.get $0 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + i32.const 0 + local.set $0 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $2 + local.get $0 + local.get $6 + i32.add + local.get $4 + local.get $0 + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $0 + i32.const 1 + i32.add + local.set $0 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $0 + local.get $2 + call $assembly/memory/ChunkBytes#constructor + local.set $0 + br $folding-inner1 + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/memory/Result#constructor (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 21 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + call $assembly/memory/MaybePageFault#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.add + i32.load8_u + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getU8 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/instructions/outcome/okOrFault (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 2 + i32.const 1 + local.get $0 + i32.load8_u offset=1 + select + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.load offset=4 + i32.store offset=16 + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getU8 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getI8 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i32.extend8_s + i64.extend_i32_s + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getI8 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getU16 (param $0 i32) (param $1 i32) (result i32) + (local $2 i64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.store offset=8 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + local.get $3 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $0 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getU16 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getI16 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store + local.get $2 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i32.or + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $0 + i32.extend16_s + i64.extend_i32_s + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getI16 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getU32 (param $0 i32) (param $1 i32) (result i32) + (local $2 i64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.store offset=8 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + local.get $3 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i64.extend_i32_u + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $0 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i64.extend_i32_u + i64.or + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getU32 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getI32 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store + local.get $2 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store + local.get $3 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store + local.get $3 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i32.or + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $0 + i64.extend_i32_s + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getI32 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#getU64 (param $0 i32) (param $1 i32) (result i32) + (local $2 i64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.const 8 + call $assembly/memory/Memory#getBytes + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.store offset=8 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + local.get $3 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 8 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 16 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 24 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 4 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 32 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 5 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 40 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $3 + i32.const 6 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 48 + i64.shl + i64.or + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i64.load + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store offset=12 + local.get $1 + local.get $2 + local.get $0 + i32.const 7 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 56 + i64.shl + i64.or + i64.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/load~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#getU64 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getU8 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getI8 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getU16 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getI16 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getU32 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getI32 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/load~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + call $assembly/memory/Memory#getU64 + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.xor + i64.const -1 + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $3 + local.get $5 + i64.add + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_u offset=8 + i64.mul + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_u offset=8 + i64.const 4294967296 + i64.or + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + local.get $4 + i32.add + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 4294967296 + i64.add + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + i64.sub + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.mul + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.tee $2 + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.div_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const -1 + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.extend32_s + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.extend32_s + local.tee $4 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const -1 + call $~lib/staticarray/StaticArray#__set + else + local.get $3 + i64.const -2147483648 + i64.eq + local.get $4 + i64.const -1 + i64.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $3 + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $3 + local.get $4 + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + local.get $2 + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.rem_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.tee $4 + if + local.get $2 + i32.const -2147483648 + i32.eq + local.get $4 + i32.const -1 + i32.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_s + local.get $4 + i64.extend_i32_s + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.sub + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const -1 + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.div_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|17 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.tee $4 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const -1 + call $~lib/staticarray/StaticArray#__set + else + local.get $3 + i64.const -9223372036854775808 + i64.eq + local.get $4 + i64.const -1 + i64.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $3 + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $3 + local.get $4 + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|18 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.rem_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|19 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.tee $4 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $3 + call $~lib/staticarray/StaticArray#__set + else + local.get $3 + i64.const -9223372036854775808 + i64.eq + local.get $4 + i64.const -1 + i64.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $3 + local.get $4 + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|20 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i64) + (local $10 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + block $__inlined_func$assembly/instructions/utils/mulUpperSigned$4 (result i64) + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + local.get $4 + i64.const 0 + i64.lt_s + if (result i32) + local.get $4 + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $4 + i32.const 1 + else + i32.const 0 + end + local.set $0 + local.get $3 + i64.const 0 + i64.lt_s + if (result i32) + local.get $3 + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $3 + local.get $0 + i32.eqz + else + local.get $0 + end + if + local.get $3 + i64.const 32 + i64.shr_u + local.tee $8 + local.get $4 + i64.const 4294967295 + i64.and + local.tee $5 + i64.mul + local.set $6 + local.get $4 + i64.const 32 + i64.shr_u + local.tee $7 + local.get $3 + i64.const 4294967295 + i64.and + local.tee $9 + i64.mul + local.set $10 + local.get $3 + local.get $4 + i64.mul + i64.eqz + i64.extend_i32_u + local.get $7 + local.get $8 + i64.mul + local.get $6 + i64.const 32 + i64.shr_u + i64.add + local.get $10 + i64.const 32 + i64.shr_u + i64.add + local.get $6 + i64.const 4294967295 + i64.and + local.get $5 + local.get $9 + i64.mul + i64.const 32 + i64.shr_u + i64.add + local.get $10 + i64.const 4294967295 + i64.and + i64.add + i64.const 32 + i64.shr_u + i64.add + i64.const -1 + i64.xor + i64.add + br $__inlined_func$assembly/instructions/utils/mulUpperSigned$4 + end + local.get $3 + i64.const 32 + i64.shr_u + local.tee $5 + local.get $4 + i64.const 4294967295 + i64.and + local.tee $6 + i64.mul + local.set $7 + local.get $4 + i64.const 32 + i64.shr_u + local.tee $4 + local.get $5 + i64.mul + local.get $7 + i64.const 32 + i64.shr_u + i64.add + local.get $3 + i64.const 4294967295 + i64.and + local.tee $3 + local.get $4 + i64.mul + local.tee $4 + i64.const 32 + i64.shr_u + i64.add + local.get $7 + i64.const 4294967295 + i64.and + local.get $3 + local.get $6 + i64.mul + i64.const 32 + i64.shr_u + i64.add + local.get $4 + i64.const 4294967295 + i64.and + i64.add + i64.const 32 + i64.shr_u + i64.add + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|21 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.tee $5 + i64.const 32 + i64.shr_u + local.set $6 + local.get $4 + i64.const 32 + i64.shr_u + local.tee $7 + local.get $5 + i64.const 4294967295 + i64.and + local.tee $5 + i64.mul + local.set $8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $6 + local.get $7 + i64.mul + local.get $4 + i64.const 4294967295 + i64.and + local.tee $3 + local.get $6 + i64.mul + local.tee $4 + i64.const 32 + i64.shr_u + i64.add + local.get $8 + i64.const 32 + i64.shr_u + i64.add + local.get $4 + i64.const 4294967295 + i64.and + local.get $3 + local.get $5 + i64.mul + i64.const 32 + i64.shr_u + i64.add + local.get $8 + i64.const 4294967295 + i64.and + i64.add + i64.const 32 + i64.shr_u + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|22 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i64) + (local $7 i64) + (local $8 i64) + (local $9 i64) + (local $10 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2376 (result i64) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $5 + local.get $3 + i64.const 0 + i64.lt_s + if + local.get $3 + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.tee $6 + i64.const 4294967295 + i64.and + local.tee $7 + local.get $5 + i64.const 32 + i64.shr_u + local.tee $8 + i64.mul + local.set $3 + local.get $6 + i64.const 32 + i64.shr_u + local.tee $4 + local.get $5 + i64.const 4294967295 + i64.and + local.tee $9 + i64.mul + local.set $10 + local.get $5 + local.get $6 + i64.mul + i64.eqz + i64.extend_i32_u + local.get $4 + local.get $8 + i64.mul + local.get $3 + i64.const 32 + i64.shr_u + i64.add + local.get $10 + i64.const 32 + i64.shr_u + i64.add + local.get $3 + i64.const 4294967295 + i64.and + local.get $7 + local.get $9 + i64.mul + i64.const 32 + i64.shr_u + i64.add + local.get $10 + i64.const 4294967295 + i64.and + i64.add + i64.const 32 + i64.shr_u + i64.add + i64.const -1 + i64.xor + i64.add + br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2376 + end + local.get $3 + i64.const 4294967295 + i64.and + local.tee $4 + local.get $5 + i64.const 32 + i64.shr_u + local.tee $6 + i64.mul + local.set $7 + local.get $3 + i64.const 32 + i64.shr_u + local.tee $3 + local.get $5 + i64.const 4294967295 + i64.and + local.tee $5 + i64.mul + local.set $8 + local.get $3 + local.get $6 + i64.mul + local.get $7 + i64.const 32 + i64.shr_u + i64.add + local.get $8 + i64.const 32 + i64.shr_u + i64.add + local.get $7 + i64.const 4294967295 + i64.and + local.get $4 + local.get $5 + i64.mul + i64.const 32 + i64.shr_u + i64.add + local.get $8 + i64.const 4294967295 + i64.and + i64.add + i64.const 32 + i64.shr_u + i64.add + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|23 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $3 + local.get $3 + local.get $4 + i64.lt_s + select + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|24 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $3 + local.get $3 + local.get $4 + i64.lt_u + select + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|25 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $3 + local.get $3 + local.get $4 + i64.gt_s + select + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|26 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $5 + i32.wrap_i64 + local.get $5 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $3 + local.get $3 + local.get $4 + i64.gt_u + select + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.rotr + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_s offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.rotr + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + local.get $0 + i32.load offset=8 + i32.rotr + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=8 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.rotr + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.rotl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $2 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.rotl + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.rotr + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $2 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.rotr + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.lt_u + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.lt_s + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.gt_u + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.gt_s + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.gt_u + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/set~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.gt_s + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 31 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.shl + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 31 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.shr_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 31 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.extend32_s + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i32.load offset=8 + local.get $2 + i32.shl + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i32.load offset=8 + local.get $2 + i32.shr_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 63 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $2 + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 63 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $2 + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 63 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + local.get $2 + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + local.get $2 + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.shl + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.shr_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.extend32_s + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $2 + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $2 + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|17 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $2 + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/typedarray/Uint8Array#__set (param $0 i32) (param $1 i32) (param $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=8 + i32.ge_u + if + i32.const 1504 + i32.const 1744 + i32.const 178 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + local.get $2 + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 2 + local.get $1 + i32.const 1 + call $assembly/memory/Memory#getChunks + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + local.get $1 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $1 + i32.store + local.get $1 + i32.const 0 + local.get $2 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=4 + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 2 + local.get $1 + i32.const 2 + call $assembly/memory/Memory#getChunks + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + local.get $1 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $1 + i32.store + local.get $1 + i32.const 0 + local.get $2 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $1 + i32.store + local.get $1 + i32.const 1 + local.get $2 + i32.const 65535 + i32.and + i32.const 8 + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $1 + i32.store + local.get $1 + i32.const 0 + local.get $2 + i32.const 65535 + i32.and + i32.const 8 + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=4 + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU32 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 2 + local.get $1 + i32.const 4 + call $assembly/memory/Memory#getChunks + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $0 + i32.store + local.get $0 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $4 + loop $for-loop|0 + local.get $3 + local.get $4 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + local.get $3 + local.get $2 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 8 + i32.shr_u + local.set $2 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + i32.const 0 + local.set $3 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $3 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + local.get $3 + local.get $2 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 8 + i32.shr_u + local.set $2 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=4 + call $assembly/memory/Memory#setU32 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU64 (param $0 i32) (param $1 i32) (param $2 i64) (result i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 2 + local.get $1 + i32.const 8 + call $assembly/memory/Memory#getChunks + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $0 + i32.store + local.get $0 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $4 + loop $for-loop|0 + local.get $3 + local.get $4 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + local.get $3 + local.get $2 + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i64.const 8 + i64.shr_u + local.set $2 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + i32.const 0 + local.set $3 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $3 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + local.get $3 + local.get $2 + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i64.const 8 + i64.shr_u + local.set $2 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i64.load32_s offset=4 + call $assembly/memory/Memory#setU64 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.add + i32.wrap_i64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=8 + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.add + i32.wrap_i64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=8 + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.add + i32.wrap_i64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i32.load offset=8 + call $assembly/memory/Memory#setU32 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=4 + i64.add + i32.wrap_i64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $1 + local.get $0 + i64.load32_s offset=8 + call $assembly/memory/Memory#setU64 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/store~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.add + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/misc~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $1 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/array/Array#get:length (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/console/console.log (param $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/bindings/dom/console.log + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory-page/Arena#acquire (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length + i32.const 0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load offset=12 + local.tee $0 + i32.const 0 + i32.le_s + if + i32.const 14144 + i32.const 9152 + i32.const 271 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.get $0 + i32.const 1 + i32.sub + local.tee $0 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 12 + i32.shl + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 14192 + i32.store + i32.const 14192 + call $~lib/console/console.log + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 536870912 + i32.lt_u + if (result i32) + i32.const 4096 + call $~lib/typedarray/Uint8Array#constructor + else + i32.const 0 + end + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=8 + i32.const 1 + i32.add + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/memory-page/RawPage#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $"~lib/map/Map#set" (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $1 + i32.const -1028477379 + i32.mul + i32.const 374761397 + i32.add + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.tee $3 + local.get $3 + i32.const 15 + i32.shr_u + i32.xor + i32.const -2048144777 + i32.mul + local.tee $3 + local.get $3 + i32.const 13 + i32.shr_u + i32.xor + i32.const -1028477379 + i32.mul + local.tee $3 + local.get $3 + i32.const 16 + i32.shr_u + i32.xor + local.tee $8 + call $"~lib/map/Map#find" + local.tee $3 + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $3 + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=12 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=12 + i32.const 3 + i32.mul + i32.const 4 + i32.div_s + i32.lt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + i32.const 1 + i32.shl + i32.const 1 + i32.or + end + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.shl + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $10 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.const 3 + i32.shl + i32.const 3 + i32.div_s + local.tee $7 + i32.const 12 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=8 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $11 + local.get $0 + i32.load offset=16 + i32.const 12 + i32.mul + i32.add + local.set $6 + local.get $4 + local.set $3 + loop $while-continue|0 + local.get $6 + local.get $11 + i32.ne + if + local.get $11 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if + local.get $3 + local.get $11 + i32.load + local.tee $12 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=4 + local.tee $5 + i32.store offset=8 + local.get $3 + local.get $5 + i32.store offset=4 + local.get $3 + local.get $10 + local.get $9 + local.get $12 + i32.const -1028477379 + i32.mul + i32.const 374761397 + i32.add + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.tee $5 + i32.const 15 + i32.shr_u + local.get $5 + i32.xor + i32.const -2048144777 + i32.mul + local.tee $5 + i32.const 13 + i32.shr_u + local.get $5 + i32.xor + i32.const -1028477379 + i32.mul + local.tee $5 + i32.const 16 + i32.shr_u + local.get $5 + i32.xor + i32.and + i32.const 2 + i32.shl + i32.add + local.tee $5 + i32.load + i32.store offset=8 + local.get $5 + local.get $3 + i32.store + local.get $3 + i32.const 12 + i32.add + local.set $3 + end + local.get $11 + i32.const 12 + i32.add + local.set $11 + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $0 + local.get $10 + i32.store + local.get $0 + local.get $10 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $0 + local.get $4 + i32.store offset=8 + local.get $0 + local.get $4 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + local.get $7 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $0 + local.get $0 + i32.load offset=20 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=16 + local.tee $4 + i32.const 1 + i32.add + i32.store offset=16 + local.get $3 + local.get $4 + i32.const 12 + i32.mul + i32.add + local.tee $3 + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $3 + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=20 + i32.const 1 + i32.add + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $3 + local.get $1 + local.get $8 + local.get $0 + i32.load offset=4 + i32.and + i32.const 2 + i32.shl + i32.add + local.tee $0 + i32.load + i32.store offset=8 + local.get $0 + local.get $3 + i32.store + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $start:assembly/instructions/misc~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $6 + local.get $2 + i64.load32_u offset=12 + i64.store + block $folding-inner0 + local.get $4 + i32.eqz + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i64.load32_u offset=12 + local.get $4 + i64.extend_i32_u + i64.add + local.tee $3 + i64.const 4294967296 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=8 + local.tee $2 + i32.store offset=4 + local.get $2 + i32.const 1 + i32.store8 + br $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $3 + i64.store32 offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $3 + i64.const 1 + i64.sub + i64.const 12 + i64.shr_s + i32.wrap_i64 + local.tee $5 + local.get $2 + i32.load + i32.eq + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.load + i32.const 1 + i32.add + local.set $4 + loop $for-loop|0 + local.get $4 + local.get $5 + i32.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + local.tee $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + call $assembly/memory-page/Arena#acquire + local.tee $7 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + i32.const 2 + local.get $7 + call $assembly/memory-page/Page#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $8 + local.get $4 + local.get $7 + call $"~lib/map/Map#set" + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $5 + i32.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + i32.load8_u + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/codec~anonymous|0 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15344 + i32.store + i32.const 15344 + call $~lib/array/Array#get:length + local.set $2 + loop $for-loop|0 + local.get $1 + local.get $2 + i32.const 255 + i32.and + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + i32.const 15344 + i32.store + i32.const 15344 + local.get $1 + call $~lib/array/Array#__get + local.get $0 + i32.const 255 + i32.and + i32.le_u + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 8 + local.get $1 + i32.sub + return + end + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $assembly/program/liftBytes (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + call $~lib/array/Array#get:length + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.lt_s + if + i32.const 1504 + i32.const 1744 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=4 + local.get $2 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/codec/Decoder#constructor (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 38 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/util/string/joinStringArray (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $1 + i32.const 1 + i32.sub + local.tee $5 + i32.const 0 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15424 + return + end + local.get $5 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + i32.const 15424 + local.get $0 + select + return + end + loop $for-loop|0 + local.get $1 + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $4 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $6 + i32.store offset=4 + local.get $6 + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $3 + local.get $6 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + i32.add + local.set $3 + end + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + i32.const 0 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $2 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + local.tee $1 + local.get $5 + i32.mul + i32.add + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $6 + i32.store offset=12 + i32.const 0 + local.set $3 + loop $for-loop|1 + local.get $3 + local.get $5 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $3 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $7 + i32.store offset=4 + local.get $7 + if + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $6 + local.get $4 + i32.const 1 + i32.shl + i32.add + local.get $7 + local.get $7 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + local.tee $7 + i32.const 1 + i32.shl + memory.copy + local.get $4 + local.get $7 + i32.add + local.set $4 + end + local.get $1 + if + local.get $6 + local.get $4 + i32.const 1 + i32.shl + i32.add + local.get $2 + local.get $1 + i32.const 1 + i32.shl + memory.copy + local.get $1 + local.get $4 + i32.add + local.set $4 + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $5 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $0 + i32.store offset=4 + local.get $0 + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $6 + local.get $4 + i32.const 1 + i32.shl + i32.add + local.get $0 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + memory.copy + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store + local.get $0 + local.get $1 + i32.const 15424 + call $~lib/util/string/joinStringArray + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/Decoder#ensureBytes (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + call $~lib/typedarray/Uint8Array#get:length + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + i32.sub + call $~lib/number/I32#toString + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 15584 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 15588 + local.get $1 + i32.store + i32.const 15584 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 15584 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 15596 + local.get $0 + i32.store + i32.const 15584 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 15584 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=4 + i32.const 15584 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 17408 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/ValOffset#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 40 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/codec/Decoder#varU32 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=4 + local.set $4 + i32.const 1 + global.set $~argumentsLength + local.get $1 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + i32.const 1 + global.set $~argumentsLength + i32.const 15392 + i32.load + call_indirect (type $2) + i32.const 255 + i32.and + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $1 + block $__inlined_func$assembly/codec/decodeVarU32$1 (result i32) + local.get $5 + i32.eqz + if + local.get $1 + i32.const 1 + call $assembly/codec/ValOffset#constructor + br $__inlined_func$assembly/codec/decodeVarU32$1 + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $5 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $5 + call $~lib/number/I32#toString + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + call $~lib/number/I32#toString + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 17632 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + i32.const 17636 + local.get $0 + i32.store + i32.const 17632 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 17632 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + i32.const 17644 + local.get $1 + i32.store + i32.const 17632 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 17632 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=12 + i32.const 17632 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 17408 + i32.const 108 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.const 1 + i32.const 8 + local.get $5 + i32.sub + local.tee $1 + i32.shl + i32.const 0 + local.get $1 + i32.const 32 + i32.lt_u + select + i32.add + i32.const 256 + i32.sub + local.get $5 + i32.const 3 + i32.shl + i32.shl + local.set $6 + local.get $5 + i32.const 1 + i32.sub + local.set $1 + loop $for-loop|0 + local.get $1 + i32.const 0 + i32.ge_s + if + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $1 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + local.get $2 + i32.const 8 + i32.shl + i32.add + local.set $2 + local.get $1 + i32.const 1 + i32.sub + local.set $1 + br $for-loop|0 + end + end + local.get $2 + local.get $6 + i32.add + local.get $5 + i32.const 1 + i32.add + call $assembly/codec/ValOffset#constructor + end + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $2 + local.get $1 + i32.load offset=4 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/codec/Decoder#bytes (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/string/String#concat (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + local.tee $3 + local.get $2 + i32.add + local.tee $4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15424 + return + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $4 + i32.store offset=4 + local.get $4 + local.get $0 + local.get $2 + memory.copy + local.get $2 + local.get $4 + i32.add + local.get $1 + local.get $3 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/string/String.__concat (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + call $~lib/string/String#concat + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/index/disassemble~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + i32.const 255 + i32.and + i32.const 16 + call $~lib/util/number/utoa32 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 15824 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 15824 + i32.store + block $__inlined_func$~lib/string/String#padStart$2455 + i32.const 15820 + i32.load + i32.const -2 + i32.and + local.tee $2 + i32.eqz + local.get $5 + i32.const 4 + i32.gt_u + i32.or + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$~lib/string/String#padStart$2455 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store offset=4 + i32.const 4 + local.get $5 + i32.sub + local.tee $4 + local.get $2 + i32.gt_u + if + local.get $4 + local.get $4 + i32.const 2 + i32.sub + local.get $2 + i32.div_u + local.get $2 + i32.mul + local.tee $7 + i32.sub + local.set $8 + loop $while-continue|0 + local.get $6 + local.get $7 + i32.lt_u + if + local.get $3 + local.get $6 + i32.add + i32.const 15824 + local.get $2 + memory.copy + local.get $2 + local.get $6 + i32.add + local.set $6 + br $while-continue|0 + end + end + local.get $3 + local.get $7 + i32.add + i32.const 15824 + local.get $8 + memory.copy + else + local.get $3 + i32.const 15824 + local.get $4 + memory.copy + end + local.get $3 + local.get $4 + i32.add + local.get $1 + local.get $5 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + local.set $1 + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + call $~lib/string/String.__concat + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/codec/Decoder#u8 (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + local.get $0 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=4 + i32.const 1 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.const 2 + i32.shl + i32.add + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/Mask#isInstruction (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i64.extend_i32_s + local.get $1 + i64.extend_i32_u + i64.le_u + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + i32.eqz + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/Mask#skipBytesToNextInstruction (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $1 + i32.const 1 + i32.add + local.tee $1 + local.get $2 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $0 + i32.eqz + if + i32.const 17824 + i32.const 9152 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/BasicBlocks#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 34 + call $~lib/rt/itcms/__new + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.store + local.get $4 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $5 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $5 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.const 2 + i32.shl + i32.const 35 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 2 + call $~lib/staticarray/StaticArray#__set + loop $for-loop|0 + local.get $3 + local.get $5 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $3 + call $assembly/program/Mask#isInstruction + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $3 + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $6 + i32.store offset=4 + local.get $6 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $6 + local.get $0 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#__get + end + i32.load8_u offset=16 + if + local.get $5 + local.get $3 + i32.const 1 + i32.add + local.get $7 + i32.add + local.tee $6 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $6 + i32.const 2 + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + local.get $3 + local.get $2 + local.get $3 + call $~lib/staticarray/StaticArray#__get + i32.const 4 + i32.or + call $~lib/staticarray/StaticArray#__set + end + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $4 + local.get $2 + i32.store + local.get $4 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/program/deblob (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i64) + (local $10 i64) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $assembly/codec/Decoder#constructor + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/codec/Decoder#varU32 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/codec/Decoder#u8 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/codec/Decoder#varU32 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + local.get $5 + i32.mul + call $assembly/codec/Decoder#bytes + local.tee $14 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $11 + call $assembly/codec/Decoder#bytes + local.tee $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $11 + i32.const 7 + i32.add + i32.const 3 + i32.shr_u + call $assembly/codec/Decoder#bytes + local.tee $12 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + global.get $~lib/memory/__stack_pointer + block $__inlined_func$assembly/program/Mask#constructor$11 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 31 + call $~lib/rt/itcms/__new + local.tee $13 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=4 + local.get $13 + i32.const 0 + i32.store + local.get $13 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $11 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.const 2 + i32.shl + i32.const 32 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $13 + local.get $0 + i32.store + local.get $13 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.sub + local.set $1 + loop $for-loop|0 + local.get $1 + i32.const 0 + i32.ge_s + if + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + local.get $1 + call $~lib/typedarray/Uint8Array#__get + local.set $0 + local.get $1 + i32.const 3 + i32.shl + local.set $15 + i32.const 7 + local.set $2 + loop $for-loop|2 + local.get $2 + i32.const 0 + i32.ge_s + if + local.get $0 + i32.const 128 + i32.and + local.set $16 + local.get $0 + i32.const 1 + i32.shl + local.set $0 + local.get $2 + local.get $15 + i32.add + local.tee $7 + local.get $11 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.load + local.tee $8 + i32.store offset=4 + local.get $8 + local.get $7 + i32.const 25 + i32.const 0 + local.get $6 + i32.const 1 + i32.add + local.get $16 + select + local.tee $6 + local.get $6 + i32.const 25 + i32.ge_u + select + call $~lib/staticarray/StaticArray#__set + end + local.get $2 + i32.const 1 + i32.sub + local.set $2 + br $for-loop|2 + end + end + local.get $1 + i32.const 1 + i32.sub + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + br $__inlined_func$assembly/program/Mask#constructor$11 + end + br $folding-inner1 + end + local.tee $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 33 + call $~lib/rt/itcms/__new + local.tee $7 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + i32.const 0 + i32.store + local.get $7 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.const 255 + i32.and + local.tee $1 + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.div_s + else + i32.const 0 + end + call $~lib/staticarray/StaticArray#constructor + local.tee $8 + i32.store offset=8 + i32.const 0 + local.set $1 + loop $for-loop|01 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.gt_s + if + i64.const 0 + local.set $4 + local.get $5 + i32.const 1 + i32.sub + i32.const 255 + i32.and + local.set $2 + loop $for-loop|1 + local.get $2 + i32.const 0 + i32.ge_s + if + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + i64.const -1 + local.get $4 + i64.const 8 + i64.shl + local.tee $9 + local.get $14 + local.get $1 + local.get $2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i64.extend_i32_u + i64.add + local.tee $10 + local.get $4 + local.get $10 + i64.gt_u + local.get $4 + local.get $9 + i64.gt_u + i32.or + select + local.set $4 + local.get $2 + i32.const 1 + i32.sub + local.set $2 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $1 + local.get $5 + i32.const 255 + i32.and + local.tee $2 + i32.div_s + local.get $4 + call $~lib/staticarray/StaticArray#__set + local.get $1 + local.get $2 + i32.add + local.set $1 + br $for-loop|01 + end + end + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $7 + local.get $8 + i32.store + local.get $7 + local.get $8 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $0 + call $assembly/program/BasicBlocks#constructor + local.tee $1 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 30 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $2 + local.get $3 + i32.store + local.get $2 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $2 + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $2 + local.get $7 + i32.store offset=8 + local.get $2 + local.get $7 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $2 + local.get $1 + i32.store offset=12 + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $0 + i32.store offset=4 + local.get $0 + i32.eqz + if + i32.const 17824 + i32.const 9152 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/program/decodeArguments (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 1264 + i32.store + i32.const 1264 + local.get $0 + call $~lib/array/Array#__get + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 1264 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 1264 + local.get $0 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#constructor + local.tee $4 + i32.store offset=4 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $3 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $4 + local.get $3 + local.get $1 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + i32.const 2 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 2272 + i32.store offset=8 + local.get $4 + local.get $2 + i32.const 2272 + local.get $0 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $1) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 2 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 2272 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 2272 + local.get $0 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $1) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/getAssembly (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 17952 + return + end + i32.const 15424 + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + loop $for-loop|0 + local.get $3 + local.get $4 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store + local.get $2 + local.get $3 + call $assembly/program/Mask#isInstruction + i32.eqz + if + i32.const 18032 + i32.const 18144 + i32.const 46 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + local.set $2 + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $5 + i32.store + local.get $2 + local.get $5 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $5 + i32.store + local.get $5 + local.get $2 + call $~lib/array/Array#__get + end + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 18224 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 18224 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + call $~lib/number/I32#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 18256 + i32.store offset=16 + local.get $7 + i32.const 18256 + call $~lib/string/String#concat + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $1 + local.get $7 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $6 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.const 255 + i32.and + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $2 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 18352 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + i32.const 18356 + local.get $2 + i32.store + i32.const 18352 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 18352 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=16 + i32.const 18352 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + local.get $2 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store + local.get $2 + local.get $3 + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $8 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + local.get $8 + local.get $3 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $6 + call $assembly/program/decodeArguments + local.tee $2 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + i32.const 42 + i32.const 0 + call $~lib/rt/__newArray + local.tee $8 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $8 + i32.const 0 + local.get $2 + i32.load + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $8 + i32.const 1 + local.get $2 + i32.load offset=4 + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $8 + i32.const 2 + local.get $2 + i32.load offset=8 + call $~lib/array/Array#__set + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $8 + i32.const 3 + local.get $2 + i32.load offset=12 + call $~lib/array/Array#__set + local.get $8 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 1136 + i32.store + i32.const 1136 + local.get $5 + i32.load offset=4 + call $~lib/array/Array#__get + local.set $5 + i32.const 0 + local.set $2 + loop $for-loop|1 + local.get $2 + local.get $5 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $8 + local.get $2 + call $~lib/array/Array#__get + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $9 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + i32.const 18448 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + i32.const 18452 + local.get $9 + i32.store + i32.const 18448 + local.get $9 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 18448 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=16 + i32.const 18448 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $1 + local.get $9 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|1 + end + end + local.get $3 + local.get $6 + i32.add + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/codec/Decoder#u24 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 3 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + local.get $0 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=4 + i32.const 3 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/Decoder#u32 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 4 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + local.get $0 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 3 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=4 + i32.const 4 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/Decoder#isExhausted (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.le_s + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/decodeSpi (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $assembly/codec/Decoder#constructor + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#u24 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#u24 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 2 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $3 + local.get $1 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get + drop + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $3 + local.get $1 + i32.load offset=4 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + drop + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $1 + i32.load offset=4 + i32.const 2 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#u24 + drop + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $2 + call $assembly/codec/Decoder#bytes + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $0 + call $assembly/codec/Decoder#bytes + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#u32 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $0 + call $assembly/codec/Decoder#bytes + local.tee $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 18480 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $0 + i32.store offset=8 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + i32.load offset=4 + i32.sub + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 18480 + local.get $0 + call $~lib/string/String#concat + i32.const 17408 + i32.const 31 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/program/deblob + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner2 + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner2 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $assembly/program/liftBytes + local.tee $3 + i32.store offset=4 + i32.const 15424 + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + local.get $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + block $__inlined_func$assembly/program/extractCodeAndMetadata$14 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + call $assembly/codec/Decoder#constructor + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/codec/Decoder#varU32 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + call $assembly/codec/Decoder#bytes + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.load offset=4 + local.set $7 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $6 + local.get $7 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.load offset=4 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $2 + local.get $6 + call $~lib/typedarray/Uint8Array#get:length + local.get $7 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 37 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $2 + local.get $6 + i32.store + local.get $2 + local.get $6 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $2 + local.get $3 + i32.store offset=4 + local.get $2 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + br $__inlined_func$assembly/program/extractCodeAndMetadata$14 + end + br $folding-inner2 + end + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 17680 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 17680 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 17728 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 17680 + i32.const 17728 + call $~lib/string/String.__concat + local.tee $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + local.tee $8 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 17760 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner2 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 17760 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + i32.load offset=4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $2 + loop $for-loop|0 + local.get $2 + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $4 + local.get $9 + i32.add + i32.load8_u + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + i32.const 4 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $5 + local.get $4 + local.get $8 + i32.const 17760 + i32.load + call_indirect (type $7) + local.tee $0 + i32.store offset=8 + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + local.get $6 + local.get $0 + call $~lib/string/String.__concat + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 17792 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 17792 + call $~lib/string/String.__concat + local.tee $0 + i32.store offset=8 + end + local.get $1 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + call $assembly/program/deblob + local.tee $1 + i32.store offset=36 + br $folding-inner1 + end + local.get $1 + i32.const 1 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + call $assembly/program/decodeSpi + local.tee $1 + i32.store offset=40 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 18608 + i32.store + local.get $1 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + i32.const 18608 + local.get $0 + call $~lib/string/String#concat + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=20 + local.get $1 + call $assembly/api-generic/getAssembly + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + local.get $0 + local.get $1 + call $~lib/string/String.__concat + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api-generic/VmInput#constructor (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 47 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 43 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store + local.get $2 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 104 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $2 + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 104 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 13 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + i32.const 1 + global.set $~argumentsLength + block $__inlined_func$~lib/array/Array#fill@varargs$16 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load offset=12 + local.tee $4 + i32.const 0 + local.get $4 + i32.const 0 + i32.le_s + select + local.tee $0 + local.get $4 + local.tee $4 + i32.lt_s + if + local.get $3 + local.get $0 + i32.const 3 + i32.shl + i32.add + i32.const 0 + local.get $4 + local.get $0 + i32.sub + i32.const 3 + i32.shl + memory.fill + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + br $__inlined_func$~lib/array/Array#fill@varargs$16 + end + br $folding-inner1 + end + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 18656 + call $~lib/rt/__newArray + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store offset=16 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 18688 + call $~lib/rt/__newArray + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store offset=20 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 18720 + call $~lib/rt/__newArray + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store offset=24 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory-page/Arena#constructor (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 16 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + local.get $0 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 524288 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 17 + i32.const 18752 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $0 + local.get $2 + i32.store + local.get $0 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 128 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $4 + i32.store offset=12 + loop $for-loop|0 + local.get $1 + i32.const 128 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $1 + i32.const 12 + i32.shl + local.tee $3 + local.get $4 + i32.const 20 + i32.sub + i32.load offset=16 + local.tee $5 + i32.gt_u + if + i32.const 1504 + i32.const 1744 + i32.const 1860 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.const 4096 + i32.add + local.get $5 + i32.gt_s + if + i32.const 9200 + i32.const 1744 + i32.const 1874 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $5 + i32.store offset=8 + local.get $5 + local.get $4 + i32.store + local.get $5 + local.get $4 + i32.const 0 + call $~lib/rt/itcms/__link + local.get $5 + i32.const 4096 + i32.store offset=8 + local.get $5 + local.get $3 + local.get $4 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $1 + local.get $5 + call $assembly/memory-page/RawPage#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $2 + i32.load offset=12 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.load offset=4 + local.tee $6 + i32.const 4 + i32.add + local.get $6 + local.get $3 + i32.const 1 + i32.sub + i32.const 2 + i32.shl + memory.copy + local.get $6 + local.get $5 + i32.store + local.get $2 + local.get $5 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory/MemoryBuilder#constructor (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 50 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.const 18 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 16 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.store + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 48 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + call $assembly/memory-page/Arena#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory/MemoryBuilder#setData (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + loop $while-continue|0 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + i32.gt_s + if + local.get $2 + i32.const 12 + i32.shr_u + local.tee $4 + i32.const 16 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + i32.const 18784 + i32.store offset=4 + local.get $4 + i32.const 10 + call $~lib/util/number/utoa32 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 18784 + local.get $0 + call $~lib/string/String#concat + i32.const 18880 + i32.const 67 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $5 + i32.store offset=4 + local.get $5 + local.get $4 + call $"~lib/map/Map#has" + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + call $assembly/memory-page/Arena#acquire + local.tee $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $1 + local.get $5 + call $assembly/memory-page/Page#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $6 + local.get $4 + local.get $5 + call $"~lib/map/Map#set" + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + local.get $4 + call $"~lib/map/Map#get" + local.tee $5 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + i32.const 4096 + local.get $2 + i32.const 4095 + i32.and + local.tee $7 + i32.sub + local.tee $4 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + local.set $4 + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + local.tee $5 + i32.store offset=16 + local.get $5 + call $assembly/memory-page/RawPage#get:data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + i32.const 0 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $~lib/typedarray/Uint8Array#get:length + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + local.get $7 + local.get $8 + i32.add + i32.lt_s + if + i32.const 1504 + i32.const 1744 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $7 + local.get $5 + i32.load offset=4 + i32.add + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.load offset=4 + local.get $8 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + local.get $4 + i32.add + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $3 + i32.store + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/memory/MemoryBuilder#build (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 15 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $0 + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $0 + local.get $3 + i32.store offset=8 + local.get $0 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + local.get $1 + i32.const 12 + i32.shr_u + local.tee $1 + i32.const 16 + i32.lt_u + if + i32.const 18944 + i32.const 18880 + i32.const 104 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $0 + local.get $1 + local.get $1 + i32.const 1 + i32.sub + local.get $3 + local.get $1 + call $"~lib/map/Map#has" + select + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api-generic/buildMemory (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + i32.const 65536 + local.set $3 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $4 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + i32.load offset=8 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + i32.load + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $0 + local.get $8 + local.get $7 + local.get $9 + call $assembly/memory/MemoryBuilder#setData + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load offset=8 + i32.const 2 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $3 + local.get $6 + i32.load + i32.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load + local.set $3 + end + end + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + local.get $5 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.tee $1 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $6 + i32.store offset=20 + i32.const 0 + local.set $4 + loop $for-loop|2 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/typedarray/Uint8Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + local.get $6 + local.get $4 + local.get $7 + local.get $4 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|2 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $0 + i32.const 0 + local.get $1 + local.get $6 + call $assembly/memory/MemoryBuilder#setData + local.get $5 + i32.const 1 + i32.add + local.set $5 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + call $assembly/memory/MemoryBuilder#build + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/interpreter/Interpreter#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 33 + i32.const 29 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store + local.get $3 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=8 + local.get $3 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=12 + local.get $3 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store8 offset=32 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $3 + local.get $0 + i32.store + local.get $3 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + i32.store offset=4 + local.get $3 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $3 + local.get $2 + i32.store offset=8 + local.get $3 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 51 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $3 + local.get $0 + i32.store offset=12 + local.get $3 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const -1 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store8 offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/util/string/joinIntegerArray (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $1 + i32.const 1 + i32.sub + local.tee $4 + i32.const 0 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15424 + return + end + local.get $4 + i32.eqz + if + local.get $0 + i64.load + i32.const 10 + call $~lib/util/number/utoa64 + local.set $0 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 18412 + i32.load + i32.const 1 + i32.shr_u + local.tee $5 + i32.const 20 + i32.add + local.get $4 + i32.mul + i32.const 20 + i32.add + local.tee $6 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store offset=4 + loop $for-loop|0 + local.get $3 + local.get $4 + i32.lt_s + if + local.get $1 + local.get $2 + i32.const 1 + i32.shl + i32.add + local.get $0 + local.get $3 + i32.const 3 + i32.shl + i32.add + i64.load + call $~lib/util/number/itoa_buffered + local.get $2 + i32.add + local.set $2 + local.get $5 + if + local.get $1 + local.get $2 + i32.const 1 + i32.shl + i32.add + i32.const 18416 + local.get $5 + i32.const 1 + i32.shl + memory.copy + local.get $2 + local.get $5 + i32.add + local.set $2 + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + local.get $6 + local.get $1 + local.get $2 + i32.const 1 + i32.shl + i32.add + local.get $0 + local.get $4 + i32.const 3 + i32.shl + i32.add + i64.load + call $~lib/util/number/itoa_buffered + local.get $2 + i32.add + local.tee $2 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.gt_s + select + local.tee $2 + local.get $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + local.tee $1 + local.get $1 + local.get $2 + i32.gt_s + select + local.tee $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.le_s + select + i32.const 1 + i32.shl + local.set $3 + block $__inlined_func$~lib/string/String#substring$2458 + local.get $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.ge_s + select + i32.const 1 + i32.shl + local.tee $2 + local.get $3 + i32.sub + local.tee $4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15424 + local.set $0 + br $__inlined_func$~lib/string/String#substring$2458 + end + local.get $3 + i32.eqz + local.get $2 + local.get $1 + i32.const 1 + i32.shl + i32.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$~lib/string/String#substring$2458 + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store offset=4 + local.get $1 + local.get $0 + local.get $3 + i32.add + local.get $4 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + local.set $0 + end + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/staticarray/StaticArray#join (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store + local.get $0 + local.get $1 + call $~lib/util/string/joinIntegerArray + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/runVm~anonymous|0 (param $0 i64) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 17728 + i32.store + local.get $0 + i32.const 16 + call $~lib/util/number/utoa64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 17728 + local.get $1 + call $~lib/string/String#concat + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + local.tee $5 + i32.const 2 + i32.const 52 + i32.const 0 + call $~lib/rt/__newArray + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=4 + local.set $6 + loop $for-loop|0 + local.get $2 + local.get $5 + i32.lt_s + if + local.get $0 + local.get $2 + i32.const 3 + i32.shl + i32.add + i64.load + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 3 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $7 + local.get $2 + local.get $0 + local.get $1 + i32.load + call_indirect (type $12) + local.tee $4 + i32.store offset=8 + local.get $6 + local.get $2 + i32.const 2 + i32.shl + i32.add + local.get $4 + i32.store + local.get $3 + local.get $4 + i32.const 1 + call $~lib/rt/itcms/__link + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/array/Array<~lib/string/String>#join (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store + i32.const 18416 + call $~lib/util/string/joinStringArray + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/resolveArguments (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner6 + block $folding-inner5 + block $folding-inner4 + block $folding-inner3 + block $folding-inner2 + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + local.get $2 + call $assembly/program/decodeArguments + local.tee $2 + i32.store offset=4 + local.get $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.const 54 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/object/Object#constructor + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + call $assembly/arguments/Args#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $6 + local.get $1 + i32.store offset=32 + local.get $6 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i32.store offset=32 + local.get $6 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + block $case13|0 + block $case12|0 + block $case11|0 + block $case8|0 + block $case5|0 + block $case4|0 + block $case2|0 + local.get $0 + br_table $folding-inner6 $folding-inner1 $case2|0 $folding-inner1 $case4|0 $case5|0 $folding-inner3 $folding-inner3 $case8|0 $folding-inner4 $folding-inner4 $case11|0 $case12|0 $case13|0 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s + i64.store + br $folding-inner2 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + br $folding-inner2 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + i64.load32_u + i64.const 32 + i64.shl + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $4 + local.get $2 + i64.load32_u offset=4 + i64.add + i64.store offset=8 + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=8 + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=12 + i64.store offset=24 + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=8 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=16 + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + i32.const 19552 + i32.store + local.get $0 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + i32.const 19552 + local.get $0 + call $~lib/string/String#concat + i32.const 19632 + i32.const 347 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s + i64.store + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=4 + i64.store offset=8 + br $folding-inner6 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=4 + i64.store offset=8 + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=8 + i64.store offset=16 + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $assembly/interpreter/branch (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 56 + call $~lib/rt/itcms/__new + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + call $~lib/object/Object#constructor + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + block $__inlined_func$assembly/program/BasicBlocks#isStart$2459 + local.get $1 + local.get $2 + i32.add + local.tee $1 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + i32.const 2 + i32.and + i32.const 0 + i32.ne + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$assembly/program/BasicBlocks#isStart$2459 + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + local.set $0 + end + local.get $0 + if + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 1 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $1 + i32.store offset=4 + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/interpreter/Interpreter#nextStep (param $0 i32) (result i32) + (local $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner6 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner6 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=20 + i32.const 3 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const -1 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=28 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const -1 + i32.store offset=28 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + block $folding-inner5 + local.get $0 + i32.load offset=20 + i32.const -1 + i32.ne + br_if $folding-inner5 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + block $folding-inner4 + local.get $0 + i32.load offset=28 + i32.const -1 + i32.ne + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=28 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const -1 + i32.store offset=28 + br $folding-inner4 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=16 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=4 + local.tee $3 + i32.store + local.get $3 + local.get $1 + call $assembly/program/Mask#isInstruction + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 + i32.store + local.get $1 + global.get $assembly/instructions/MISSING_INSTRUCTION + i64.load offset=8 + call $assembly/gas/GasCounter#sub@override + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 4 + i32.store offset=20 + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store offset=20 + end + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load + local.tee $3 + i32.store + local.get $3 + local.get $1 + call $~lib/typedarray/Uint8Array#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length + local.get $3 + i32.gt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $4 + i32.store + local.get $4 + local.get $3 + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $5 + i32.store + block $folding-inner3 + block $folding-inner1 + block $folding-inner0 + local.get $5 + local.get $4 + i64.load offset=8 + call $assembly/gas/GasCounter#sub@override + br_if $folding-inner0 + local.get $4 + global.get $assembly/instructions/MISSING_INSTRUCTION + i32.eq + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + local.tee $5 + i32.store + local.get $5 + local.get $1 + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $8 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.load + local.tee $8 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + local.get $8 + local.get $1 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $5 + call $assembly/program/decodeArguments + local.tee $6 + i32.store offset=16 + local.get $4 + global.get $assembly/instructions/SBRK + i32.eq + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u offset=32 + else + i32.const 0 + end + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $4 + i32.const 12 + local.get $6 + i64.load32_u + local.tee $2 + i32.wrap_i64 + local.get $2 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + i64.const 4095 + i64.add + i64.const 12 + i64.shr_u + i64.const 4 + i64.shl + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $4 + i32.store + local.get $4 + local.get $2 + call $assembly/gas/GasCounter#sub@override + br_if $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + i32.const 15264 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15264 + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.tee $3 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $7 + i32.store offset=8 + i32.const 3 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $6 + local.get $4 + local.get $7 + local.get $3 + i32.load + call_indirect (type $0) + local.tee $3 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + block $break|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $3 + i32.load + br_table $case3|0 $case1|0 $case0|0 $case2|0 $break|0 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $__inlined_func$assembly/interpreter/dJump$17 + block $folding-inner11 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner6 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner6 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 55 + call $~lib/rt/itcms/__new + local.tee $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + call $~lib/object/Object#constructor + local.tee $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $3 + i32.const -65536 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + i32.store + br $__inlined_func$assembly/interpreter/dJump$17 + end + local.get $3 + i32.const 1 + i32.and + i32.const 1 + local.get $3 + select + br_if $folding-inner11 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $4 + i32.store offset=4 + local.get $3 + i32.const 1 + i32.shr_u + i32.const 1 + i32.sub + local.tee $3 + local.get $4 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.ge_u + br_if $folding-inner11 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $1 + i32.store offset=4 + local.get $1 + local.get $3 + call $~lib/staticarray/StaticArray#__get + local.tee $2 + i64.const 4294967296 + i64.ge_u + br_if $folding-inner11 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $2 + i64.store32 offset=4 + br $__inlined_func$assembly/interpreter/dJump$17 + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 2 + i32.store + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + local.tee $1 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.load + i32.const 1 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=20 + br $folding-inner4 + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load + i32.const 2 + i32.eq + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=12 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $1 + i32.load offset=4 + i32.const 0 + call $assembly/interpreter/branch + local.tee $1 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load8_u + i32.eqz + br_if $folding-inner1 + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load offset=12 + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + local.get $1 + local.get $3 + i32.load offset=4 + call $assembly/interpreter/branch + local.tee $1 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load8_u + i32.eqz + br_if $folding-inner1 + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=12 + i32.const 3 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 3 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $0 + local.get $3 + i32.load offset=16 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=16 + i32.const 1 + i32.add + local.get $5 + i32.add + i32.store offset=28 + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=12 + i32.const 1 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 + i32.store + local.get $1 + i64.const 1 + call $assembly/gas/GasCounter#sub@override + drop + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=16 + i32.const 65536 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store offset=20 + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 2 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $0 + local.get $3 + i32.load offset=16 + i32.store offset=24 + end + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=12 + i32.const 2 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 + i32.store + local.get $1 + i64.const 1 + call $assembly/gas/GasCounter#sub@override + drop + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=12 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $0 + local.get $3 + i32.load offset=16 + i32.store offset=24 + br $folding-inner5 + end + i32.const 19968 + i32.const 20016 + i32.const 173 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=16 + local.get $5 + i32.const 1 + i32.add + i32.add + i32.store offset=16 + br $folding-inner4 + end + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 4 + i32.store offset=20 + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store offset=20 + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.load offset=4 + i32.store offset=16 + end + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 1 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/array/Array#set:length (param $0 i32) (param $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + local.get $1 + i32.const 2 + i32.const 0 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#push (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $0 + i32.load offset=12 + local.tee $2 + i32.const 1 + i32.add + local.tee $3 + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.load offset=4 + i32.add + local.get $1 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/InitialChunk#constructor (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 45 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 20192 + call $~lib/rt/__newArray + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/array/Array#push (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $0 + i32.load offset=12 + local.tee $2 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $2 + i32.const 2 + i32.shl + i32.add + local.get $1 + i32.store + local.get $0 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-generic/getOutputChunks (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 20160 + call $~lib/rt/__newArray + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.load offset=8 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.load offset=16 + local.set $8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 42 + call $~lib/rt/itcms/__new + local.tee $9 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store + local.get $9 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=12 + local.get $8 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9152 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + local.get $8 + local.get $8 + i32.const 8 + i32.le_u + select + i32.const 2 + i32.shl + local.tee $10 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $9 + local.get $5 + i32.store + local.get $9 + local.get $5 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $10 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $8 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + loop $for-loop|0 + local.get $2 + local.get $8 + i32.lt_s + if + local.get $7 + local.get $2 + i32.const 12 + i32.mul + i32.add + local.tee $5 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $1 + local.get $5 + i32.load + call $~lib/array/Array#__set + local.get $1 + i32.const 1 + i32.add + local.set $1 + end + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $1 + call $~lib/array/Array#set:length + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + i32.const 0 + local.set $1 + loop $for-loop|00 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/array/Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $4 + call $~lib/array/Array#__get + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $5 + call $"~lib/map/Map#get" + local.tee $6 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $2 + i32.store offset=4 + local.get $2 + i32.load offset=4 + if + i32.const 0 + local.set $2 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + local.get $7 + call $assembly/memory-page/RawPage#get:data + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + local.get $7 + call $assembly/memory-page/RawPage#get:data + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $2 + call $~lib/typedarray/Uint8Array#__get + local.tee $7 + if + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $8 + i32.store offset=4 + local.get $8 + local.get $7 + call $~lib/array/Array#push + else + global.get $~lib/memory/__stack_pointer + call $assembly/api-generic/InitialChunk#constructor + local.tee $1 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $5 + i32.const 12 + i32.shl + local.get $2 + i32.add + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 1 + i32.const 0 + i32.const 27 + i32.const 0 + call $~lib/rt/__newArray + local.tee $8 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.load offset=12 + i32.eqz + if + local.get $8 + i32.const 1 + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + i32.store offset=12 + end + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.load offset=4 + local.get $7 + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $1 + local.get $8 + i32.store offset=4 + local.get $1 + local.get $8 + i32.const 0 + call $~lib/rt/itcms/__link + end + else + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + call $~lib/array/Array#push + i32.const 0 + local.set $1 + end + end + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|1 + end + end + end + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|00 + end + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + call $~lib/array/Array#push + end + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $"~lib/map/Map#values" (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=16 + local.set $2 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 57 + call $~lib/rt/itcms/__new + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + i32.store + local.get $6 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + i32.store offset=12 + local.get $2 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9152 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + local.get $2 + local.get $2 + i32.const 8 + i32.le_u + select + i32.const 2 + i32.shl + local.tee $0 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $6 + local.get $5 + i32.store + local.get $6 + local.get $5 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + loop $for-loop|0 + local.get $2 + local.get $3 + i32.gt_s + if + local.get $4 + local.get $3 + i32.const 12 + i32.mul + i32.add + local.tee $5 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $1 + local.tee $0 + i32.const 1 + i32.add + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $0 + local.get $6 + i32.load offset=12 + i32.ge_u + if + local.get $0 + i32.const 0 + i32.lt_s + if + i32.const 1504 + i32.const 9152 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $6 + local.get $0 + i32.const 1 + i32.add + local.tee $5 + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $5 + i32.store offset=12 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load offset=4 + local.get $0 + i32.const 2 + i32.shl + i32.add + local.get $7 + i32.store + local.get $6 + local.get $7 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $1 + call $~lib/array/Array#set:length + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api-generic/runVm (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + (local $17 i32) + global.get $~lib/memory/__stack_pointer + i32.const 124 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 124 + memory.fill + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=16 + local.tee $7 + i32.store offset=4 + local.get $7 + call $assembly/program/liftBytes + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $assembly/program/deblob + local.tee $10 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 13 + call $~lib/staticarray/StaticArray#constructor + local.tee $6 + i32.store offset=16 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $3 + local.get $6 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $3 + local.get $7 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + i32.load offset=4 + local.get $3 + i32.const 3 + i32.shl + i32.add + i64.load + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + local.get $3 + local.get $5 + call $~lib/staticarray/StaticArray#__set + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + call $assembly/memory/MemoryBuilder#constructor + local.tee $3 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=20 + local.tee $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=24 + local.tee $8 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $7 + local.get $8 + call $assembly/api-generic/buildMemory + local.tee $3 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $10 + local.get $6 + local.get $3 + call $assembly/interpreter/Interpreter#constructor + local.tee $11 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $2 + i32.store8 offset=32 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $11 + local.get $0 + i32.load offset=4 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=12 + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i64.load offset=8 + call $assembly/gas/GasCounter#set@override + i32.const 1 + local.set $0 + loop $for-loop|1 + block $for-break1 + local.get $0 + i32.eqz + if + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + call $~lib/staticarray/StaticArray#join + local.tee $0 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + i32.const 19152 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19156 + local.get $0 + i32.store + i32.const 19152 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19152 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + i32.const 19152 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 19216 + i32.store offset=40 + local.get $6 + i32.const 19216 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store offset=8 + local.get $2 + call $~lib/array/Array<~lib/string/String>#join + local.tee $0 + i32.store offset=44 + global.get $~lib/memory/__stack_pointer + i32.const 19184 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19188 + local.get $0 + i32.store + i32.const 19184 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19184 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + i32.const 19184 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 19248 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + local.get $11 + i32.load offset=20 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19248 + local.get $0 + call $~lib/string/String#concat + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + br $for-break1 + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 19312 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + local.get $11 + i32.load offset=16 + i32.const 10 + call $~lib/util/number/utoa32 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19312 + local.get $0 + call $~lib/string/String#concat + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 19344 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + local.get $11 + i32.load offset=20 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19344 + local.get $0 + call $~lib/string/String#concat + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 19056 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store offset=40 + local.get $6 + call $~lib/staticarray/StaticArray#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19056 + local.get $0 + call $~lib/string/String#concat + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 19056 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=48 + global.get $~lib/memory/__stack_pointer + i32.const 19392 + i32.store offset=52 + local.get $6 + i32.const 19392 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store offset=40 + local.get $0 + call $~lib/array/Array<~lib/string/String>#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19056 + local.get $0 + call $~lib/string/String#concat + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.load offset=16 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $2 + i32.store + local.get $2 + call $~lib/typedarray/Uint8Array#get:length + local.get $0 + i32.gt_u + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $0 + local.get $11 + i32.load offset=16 + call $~lib/typedarray/Uint8Array#__get + else + i32.const 0 + end + local.set $0 + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $2 + i32.store + local.get $0 + local.get $2 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $2 + i32.store + local.get $2 + local.get $0 + call $~lib/array/Array#__get + end + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.load offset=4 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $3 + local.get $11 + i32.load offset=16 + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $7 + i32.store offset=56 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=60 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 255 + i32.and + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $0 + i32.store offset=64 + global.get $~lib/memory/__stack_pointer + i32.const 19504 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + i32.const 19508 + local.get $7 + i32.store + i32.const 19504 + local.get $7 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19504 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19516 + local.get $0 + i32.store + i32.const 19504 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19504 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + i32.const 19504 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load + local.tee $7 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.load + local.tee $7 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + local.get $11 + i32.load offset=16 + i32.const 1 + i32.add + local.set $8 + i32.const 1 + global.set $~argumentsLength + local.get $7 + local.get $8 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=4 + local.tee $8 + i32.store offset=4 + local.get $7 + local.get $3 + local.get $8 + call $assembly/program/resolveArguments + local.tee $12 + i32.store offset=68 + local.get $12 + if + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load + call $~lib/util/number/itoa64 + local.tee $0 + i32.store offset=72 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.load offset=32 + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $2 + i32.store offset=76 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $3 + i32.store offset=80 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=8 + call $~lib/util/number/itoa64 + local.tee $7 + i32.store offset=84 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.load offset=32 + local.tee $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.load offset=4 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $8 + i32.store offset=88 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=8 + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $13 + i32.store offset=92 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=16 + call $~lib/util/number/itoa64 + local.tee $14 + i32.store offset=96 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.load offset=32 + local.tee $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.load offset=8 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $9 + i32.store offset=100 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=16 + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $15 + i32.store offset=104 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=24 + call $~lib/util/number/itoa64 + local.tee $16 + i32.store offset=108 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.load offset=32 + local.tee $17 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.load offset=12 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $17 + i32.store offset=112 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i64.load offset=24 + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $12 + i32.store offset=116 + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 19844 + local.get $0 + i32.store + i32.const 19840 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + i32.const 19852 + local.get $2 + i32.store + i32.const 19840 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + i32.const 19860 + local.get $3 + i32.store + i32.const 19840 + local.get $3 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + i32.const 19868 + local.get $7 + i32.store + i32.const 19840 + local.get $7 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + i32.const 19876 + local.get $8 + i32.store + i32.const 19840 + local.get $8 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + i32.const 19884 + local.get $13 + i32.store + i32.const 19840 + local.get $13 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + i32.const 19892 + local.get $14 + i32.store + i32.const 19840 + local.get $14 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + i32.const 19900 + local.get $9 + i32.store + i32.const 19840 + local.get $9 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store offset=8 + i32.const 19908 + local.get $15 + i32.store + i32.const 19840 + local.get $15 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + i32.const 19916 + local.get $16 + i32.store + i32.const 19840 + local.get $16 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=8 + i32.const 19924 + local.get $17 + i32.store + i32.const 19840 + local.get $17 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + i32.const 19932 + local.get $12 + i32.store + i32.const 19840 + local.get $12 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19840 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=8 + i32.const 19840 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/console/console.log + end + end + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $assembly/interpreter/Interpreter#nextStep + local.set $0 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 44 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/object/Object#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const -1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 0 + i32.const 3 + i32.const 43 + i32.const 20096 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.store offset=4 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 20128 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.store offset=12 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=120 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $1 + local.get $11 + i32.load offset=20 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=4 + local.tee $0 + i32.store offset=8 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.tee $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.gt_s + select + local.tee $2 + i32.const 3 + i32.const 43 + i32.const 0 + call $~lib/rt/__newArray + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=4 + local.get $0 + local.get $2 + i32.const 3 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $1 + local.get $3 + i32.store offset=4 + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $1 + local.get $11 + i32.load offset=16 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=12 + local.tee $0 + i32.store offset=4 + local.get $1 + local.get $0 + call $assembly/gas/GasCounter#get@override + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=8 + local.tee $0 + i32.store offset=8 + local.get $0 + call $assembly/api-generic/getOutputChunks + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + local.get $0 + i32.store offset=12 + local.get $1 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $1 + local.get $11 + i32.load offset=24 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=8 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + call $"~lib/map/Map#values" + local.tee $2 + i32.store offset=8 + loop $for-loop|01 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $2 + local.get $4 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $3 + local.get $6 + call $~lib/array/Array#push + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|01 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 16 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.store + local.get $0 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 48 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.store offset=8 + local.get $0 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 4 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 124 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/program-build/skipBytes (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $folding-inner3 (result i32) + block $folding-inner2 + block $folding-inner1 + block $folding-inner0 + block $case13|0 + block $case12|0 + block $case11|0 + block $case8|0 + block $case7|0 + block $case6|0 + block $case5|0 + block $case4|0 + block $case2|0 + block $case0|0 + local.get $0 + br_table $case0|0 $folding-inner0 $case2|0 $folding-inner0 $case4|0 $case5|0 $case6|0 $case7|0 $case8|0 $folding-inner2 $folding-inner2 $case11|0 $case12|0 $case13|0 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u + i32.const 1 + i32.add + local.tee $0 + i32.const 255 + i32.and + i32.const 1 + i32.add + block $__inlined_func$assembly/program-build/immBytes$2177 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $1 + local.get $0 + i32.const 1 + i32.add + i32.const 255 + i32.and + local.tee $0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$2177 + drop + local.get $1 + local.get $0 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.add + br $folding-inner3 + end + block $__inlined_func$assembly/program-build/immBytes$2179 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $0 + i32.const 0 + i32.le_s + br_if $__inlined_func$assembly/program-build/immBytes$2179 + drop + local.get $0 + i32.const 1 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.const 1 + i32.add + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 9 + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=8 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=12 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 1 + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u + i32.const 1 + i32.add + local.tee $0 + i32.const 255 + i32.and + i32.const 2 + i32.add + block $__inlined_func$assembly/program-build/immBytes$2185 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $1 + local.get $0 + i32.const 255 + i32.and + i32.const 2 + i32.add + local.tee $0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$2185 + drop + local.get $1 + local.get $0 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.add + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 2 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 19552 + i32.store + local.get $0 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + i32.const 19552 + local.get $0 + call $~lib/string/String#concat + i32.const 20368 + i32.const 73 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + block $__inlined_func$assembly/program-build/immBytes$2175 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $0 + i32.const 0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$2175 + drop + local.get $0 + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u offset=1 + i32.const 1 + i32.add + local.tee $0 + i32.const 255 + i32.and + i32.const 1 + i32.add + block $__inlined_func$assembly/program-build/immBytes$2181 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $1 + local.get $0 + i32.const 255 + i32.and + i32.const 1 + i32.add + local.tee $0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$2181 + drop + local.get $1 + local.get $0 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.add + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + i32.const 1 + i32.add + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program-build/buildMask (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $3 + i32.const 1073741820 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.const 58 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $2 + call $~lib/typedarray/Uint8Array#__get + local.set $1 + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length + local.get $1 + i32.gt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $4 + i32.store + local.get $4 + local.get $1 + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $2 + i32.const 1 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 1264 + i32.store + i32.const 1264 + local.get $1 + i32.load offset=4 + call $~lib/array/Array#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $4 + local.get $2 + i32.const 1 + i32.add + local.tee $4 + i32.add + i32.ge_s + if (result i32) + local.get $1 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 1 + global.set $~argumentsLength + local.get $0 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/program-build/skipBytes + local.get $2 + i32.add + else + local.get $2 + end + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 20448 + call $~lib/rt/__newArray + local.tee $4 + i32.store offset=12 + i32.const 0 + local.set $0 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $0 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + i32.lt_s + if + i32.const 0 + local.set $2 + local.get $0 + local.set $1 + loop $for-loop|3 + local.get $1 + local.get $0 + i32.const 8 + i32.add + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $2 + i32.const 255 + i32.and + i32.const 1 + i32.shr_u + local.tee $2 + i32.const 128 + i32.or + local.get $2 + local.get $1 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + i32.lt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $1 + call $~lib/staticarray/StaticArray#__get + else + i32.const 0 + end + select + local.set $2 + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|3 + end + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $2 + call $~lib/array/Array#push + local.get $0 + i32.const 8 + i32.add + local.set $0 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/codec/encodeVarU32 (param $0 i64) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i64) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner2 + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner2 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + local.get $0 + i64.eqz + if + i32.const 1 + call $~lib/typedarray/Uint8Array#constructor + local.set $3 + br $folding-inner1 + end + local.get $0 + i64.const 72057594037927936 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + i32.const 9 + call $~lib/typedarray/Uint8Array#constructor + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 255 + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $3 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + block $__inlined_func$~lib/dataview/DataView#constructor@varargs$38 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 59 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store + local.get $1 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + local.get $5 + i32.lt_u + local.get $5 + i32.const 1073741820 + i32.gt_u + i32.or + if + i32.const 9200 + i32.const 20480 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $1 + local.get $3 + i32.store + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + br $__inlined_func$~lib/dataview/DataView#constructor@varargs$38 + end + br $folding-inner2 + end + local.tee $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner2 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load offset=8 + i32.const 9 + i32.lt_s + if + i32.const 1504 + i32.const 20480 + i32.const 174 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load offset=4 + local.get $0 + i64.store offset=1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i64.const 562949953421312 + local.set $4 + i32.const 7 + local.set $1 + loop $for-loop|0 + local.get $1 + i32.const 0 + i32.ge_s + if + local.get $0 + local.get $4 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $3 + i32.store offset=16 + i32.const 256 + i32.const 1 + i32.const 8 + local.get $1 + i32.sub + local.tee $2 + i32.shl + i32.const 0 + local.get $2 + i32.const 32 + i32.lt_u + select + i32.sub + i64.extend_i32_s + local.get $0 + i32.const 1 + local.get $1 + i32.const 3 + i32.shl + local.tee $2 + i32.shl + i32.const 0 + local.get $2 + i32.const 32 + i32.lt_u + select + i64.extend_i32_s + local.tee $4 + i64.div_u + i64.add + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + local.get $6 + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $0 + local.get $4 + i64.rem_u + local.set $0 + i32.const 1 + local.set $2 + loop $for-loop|1 + local.get $2 + local.get $1 + i32.const 1 + i32.add + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $2 + local.get $0 + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $0 + i64.const 8 + i64.shr_u + local.set $0 + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|1 + end + end + br $folding-inner1 + end + local.get $4 + i64.const 7 + i64.shr_u + local.set $4 + local.get $1 + i32.const 1 + i32.sub + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20544 + i32.store offset=4 + local.get $0 + i32.const 10 + call $~lib/util/number/utoa64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + i32.const 20544 + local.get $1 + call $~lib/string/String#concat + i32.const 17408 + i32.const 160 + i32.const 3 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api/fillRegisters (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -8 + i32.and + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length + local.get $3 + i32.ne + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/array/Array#get:length + call $~lib/number/I32#toString + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + call $~lib/number/I32#toString + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 20768 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + i32.const 20772 + local.get $0 + i32.store + i32.const 20768 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 20768 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + i32.const 20780 + local.get $1 + i32.store + i32.const 20768 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 20768 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15424 + i32.store offset=12 + i32.const 20768 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 20816 + i32.const 166 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.lt_s + if + i64.const 0 + local.set $4 + i32.const 0 + local.set $3 + loop $for-loop|1 + local.get $3 + i32.const 8 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $4 + local.get $1 + local.get $2 + i32.const 3 + i32.shl + local.get $3 + i32.add + call $~lib/array/Array#__get + i64.extend_i32_u + local.get $3 + i32.const 3 + i32.shl + i32.const 255 + i32.and + i64.extend_i32_u + i64.shl + i64.or + local.set $4 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $2 + local.get $4 + call $~lib/staticarray/StaticArray#__set + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $assembly/program/liftBytes + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/program/deblob + local.tee $7 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 13 + call $~lib/staticarray/StaticArray#constructor + local.tee $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $5 + local.get $1 + call $assembly/api/fillRegisters + global.get $~lib/memory/__stack_pointer + call $assembly/memory/MemoryBuilder#constructor + local.tee $8 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=24 + block $__inlined_func$assembly/api/readPages$43 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 20880 + call $~lib/rt/__newArray + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + call $assembly/codec/Decoder#constructor + local.tee $2 + i32.store offset=8 + loop $while-continue|0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 48 + call $~lib/rt/itcms/__new + local.tee $9 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + call $~lib/object/Object#constructor + local.tee $9 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $9 + local.get $2 + call $assembly/codec/Decoder#u32 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $9 + local.get $2 + call $assembly/codec/Decoder#u32 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $9 + i32.const 2 + i32.const 1 + local.get $2 + call $assembly/codec/Decoder#u8 + select + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $1 + local.get $9 + call $~lib/array/Array#push + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + br $__inlined_func$assembly/api/readPages$43 + end + br $folding-inner1 + end + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 46 + i32.const 20912 + call $~lib/rt/__newArray + local.tee $10 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + call $assembly/codec/Decoder#constructor + local.tee $1 + i32.store offset=8 + loop $while-continue|01 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + call $assembly/api-generic/InitialChunk#constructor + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + local.get $2 + local.get $1 + call $assembly/codec/Decoder#u32 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $assembly/codec/Decoder#u32 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $11 + call $assembly/codec/Decoder#bytes + local.tee $6 + i32.store offset=20 + i32.const 0 + local.set $3 + loop $for-loop|1 + local.get $3 + local.get $11 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + local.tee $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=16 + local.get $12 + local.get $6 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#push + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $10 + local.get $2 + call $~lib/array/Array#push + br $while-continue|01 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=20 + local.get $8 + local.get $9 + local.get $10 + call $assembly/api-generic/buildMemory + local.tee $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $7 + local.get $5 + local.get $0 + call $assembly/interpreter/Interpreter#constructor + local.tee $0 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 + i32.store + local.get $1 + local.get $4 + call $assembly/gas/GasCounter#set@override + local.get $0 + global.set $assembly/api/interpreter + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api/nextStep (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 43 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + call $assembly/interpreter/Interpreter#nextStep + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $assembly/api/nSteps (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 51 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + i32.const 1 + local.set $2 + loop $for-loop|0 + local.get $0 + local.get $3 + i32.gt_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/interpreter/Interpreter#nextStep + local.tee $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $assembly/api/getProgramCounter (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 68 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/setNextProgramCounter (param $0 i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 76 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/getStatus (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 1 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 84 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=20 + i32.const 255 + i32.and + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/getExitArg (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 92 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=24 + local.tee $0 + i32.eqz + if + i32.const 0 + local.set $0 + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/api/getGasLeft (result i64) + (local $0 i32) + (local $1 i64) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + i64.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 100 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $0 + i32.store offset=8 + local.get $0 + call $assembly/gas/GasCounter#get@override + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/setGasLeft (param $0 i64) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 106 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=12 + local.tee $1 + i32.store offset=8 + local.get $1 + local.get $0 + call $assembly/gas/GasCounter#set@override + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api/getRegisters (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 104 + call $~lib/typedarray/Uint8Array#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + i32.const 1 + global.set $~argumentsLength + local.get $3 + call $~lib/typedarray/Uint8Array#fill@varargs + local.tee $4 + i32.store offset=4 + global.get $assembly/api/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 117 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.store offset=12 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=4 + local.tee $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + local.set $2 + i32.const 0 + local.set $0 + loop $for-loop|1 + local.get $0 + i32.const 8 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $1 + i32.const 3 + i32.shl + local.get $0 + i32.add + local.get $2 + i64.const 255 + i64.and + i32.wrap_i64 + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i64.const 8 + i64.shr_u + local.set $2 + local.get $0 + i32.const 1 + i32.add + local.set $0 + br $for-loop|1 + end + end + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/api/getPageDump (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api/interpreter + i32.eqz + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 142 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.tee $1 + i32.store + block $__inlined_func$assembly/memory/Memory#pageDump$2440 + local.get $1 + local.get $0 + call $"~lib/map/Map#has" + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + local.set $0 + br $__inlined_func$assembly/memory/Memory#pageDump$2440 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.tee $1 + i32.store offset=8 + local.get $1 + local.get $0 + call $"~lib/map/Map#get" + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + call $assembly/memory-page/RawPage#get:data + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + end + local.get $0 + i32.store offset=16 + local.get $0 + i32.eqz + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + i32.const 4096 + call $~lib/typedarray/Uint8Array#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 1 + global.set $~argumentsLength + local.get $0 + call $~lib/typedarray/Uint8Array#fill@varargs + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/object/Object#constructor (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/rt/__newArray (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + i32.shl + local.tee $5 + i32.const 1 + call $~lib/rt/itcms/__new + local.set $1 + local.get $3 + if + local.get $1 + local.get $3 + local.get $5 + memory.copy + end + local.get $1 + i32.store + i32.const 16 + local.get $2 + call $~lib/rt/itcms/__new + local.tee $2 + local.get $1 + i32.store + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + local.get $2 + local.get $1 + i32.store offset=4 + local.get $2 + local.get $5 + i32.store offset=8 + local.get $2 + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/staticarray/StaticArray#constructor (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i32.const 1073741820 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 23 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/arraybuffer/ArrayBuffer#constructor (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i32.const 1073741820 + i32.gt_u + if + i32.const 9200 + i32.const 9248 + i32.const 52 + i32.const 43 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/util/number/utoa32 (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i64) + (local $4 i64) + (local $5 i64) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $1 + i32.const 2 + i32.lt_s + local.get $1 + i32.const 36 + i32.gt_s + i32.or + if + i32.const 15632 + i32.const 15760 + i32.const 350 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15824 + return + end + local.get $1 + i32.const 10 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 100000 + i32.lt_u + if (result i32) + local.get $0 + i32.const 100 + i32.lt_u + if (result i32) + local.get $0 + i32.const 10 + i32.ge_u + i32.const 1 + i32.add + else + local.get $0 + i32.const 10000 + i32.ge_u + i32.const 3 + i32.add + local.get $0 + i32.const 1000 + i32.ge_u + i32.add + end + else + local.get $0 + i32.const 10000000 + i32.lt_u + if (result i32) + local.get $0 + i32.const 1000000 + i32.ge_u + i32.const 6 + i32.add + else + local.get $0 + i32.const 1000000000 + i32.ge_u + i32.const 8 + i32.add + local.get $0 + i32.const 100000000 + i32.ge_u + i32.add + end + end + local.tee $1 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + local.get $2 + local.get $0 + local.get $1 + call $~lib/util/number/utoa32_dec_lut + else + local.get $1 + i32.const 16 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 31 + local.get $0 + i32.clz + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.tee $1 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + local.get $0 + i64.extend_i32_u + local.set $3 + loop $while-continue|0 + local.get $1 + i32.const 2 + i32.ge_u + if + local.get $2 + local.get $1 + i32.const 2 + i32.sub + local.tee $1 + i32.const 1 + i32.shl + i32.add + local.get $3 + i32.wrap_i64 + i32.const 255 + i32.and + i32.const 2 + i32.shl + i32.const 16256 + i32.add + i32.load + i32.store + local.get $3 + i64.const 8 + i64.shr_u + local.set $3 + br $while-continue|0 + end + end + local.get $1 + i32.const 1 + i32.and + if + local.get $2 + local.get $3 + i32.wrap_i64 + i32.const 6 + i32.shl + i32.const 16256 + i32.add + i32.load16_u + i32.store16 + end + else + global.get $~lib/memory/__stack_pointer + block $__inlined_func$~lib/util/number/ulog_base$2258 (result i32) + local.get $0 + i64.extend_i32_u + local.set $4 + local.get $1 + i32.popcnt + i32.const 1 + i32.eq + if + i32.const 63 + local.get $4 + i64.clz + i32.wrap_i64 + i32.sub + i32.const 31 + local.get $1 + i32.clz + i32.sub + i32.div_u + i32.const 1 + i32.add + br $__inlined_func$~lib/util/number/ulog_base$2258 + end + local.get $1 + i64.extend_i32_s + local.tee $5 + local.set $3 + i32.const 1 + local.set $2 + loop $while-continue|01 + local.get $3 + local.get $4 + i64.le_u + if + local.get $4 + local.get $3 + i64.div_u + local.set $4 + local.get $3 + local.get $3 + i64.mul + local.set $3 + local.get $2 + i32.const 1 + i32.shl + local.set $2 + br $while-continue|01 + end + end + loop $while-continue|1 + local.get $4 + i64.const 0 + i64.ne + if + local.get $4 + local.get $5 + i64.div_u + local.set $4 + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $while-continue|1 + end + end + local.get $2 + i32.const 1 + i32.sub + end + local.tee $6 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + local.get $2 + local.get $0 + i64.extend_i32_u + local.get $6 + local.get $1 + call $~lib/util/number/utoa64_any_core + end + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/staticarray/StaticArray#constructor (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i32.const 134217727 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 3 + i32.shl + i32.const 14 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/util/number/utoa64 (param $0 i64) (param $1 i32) (result i32) + (local $2 i64) + (local $3 i32) + (local $4 i64) + (local $5 i64) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $1 + i32.const 2 + i32.lt_s + local.get $1 + i32.const 36 + i32.gt_s + i32.or + if + i32.const 15632 + i32.const 15760 + i32.const 401 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15824 + return + end + local.get $1 + i32.const 10 + i32.eq + if + local.get $0 + i64.const 4294967295 + i64.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.wrap_i64 + local.tee $1 + i32.const 100000 + i32.lt_u + if (result i32) + local.get $1 + i32.const 100 + i32.lt_u + if (result i32) + local.get $1 + i32.const 10 + i32.ge_u + i32.const 1 + i32.add + else + local.get $1 + i32.const 10000 + i32.ge_u + i32.const 3 + i32.add + local.get $1 + i32.const 1000 + i32.ge_u + i32.add + end + else + local.get $1 + i32.const 10000000 + i32.lt_u + if (result i32) + local.get $1 + i32.const 1000000 + i32.ge_u + i32.const 6 + i32.add + else + local.get $1 + i32.const 1000000000 + i32.ge_u + i32.const 8 + i32.add + local.get $1 + i32.const 100000000 + i32.ge_u + i32.add + end + end + local.tee $6 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + local.get $3 + local.get $1 + local.get $6 + call $~lib/util/number/utoa32_dec_lut + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i64.const 1000000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 1000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 100000000000 + i64.ge_u + i32.const 10 + i32.add + local.get $0 + i64.const 10000000000 + i64.ge_u + i32.add + else + local.get $0 + i64.const 100000000000000 + i64.ge_u + i32.const 13 + i32.add + local.get $0 + i64.const 10000000000000 + i64.ge_u + i32.add + end + else + local.get $0 + i64.const 100000000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 10000000000000000 + i64.ge_u + i32.const 16 + i32.add + else + local.get $0 + i64.const -8446744073709551616 + i64.ge_u + i32.const 18 + i32.add + local.get $0 + i64.const 1000000000000000000 + i64.ge_u + i32.add + end + end + local.tee $1 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + local.get $3 + local.get $0 + local.get $1 + call $~lib/util/number/utoa64_dec_lut + end + else + local.get $1 + i32.const 16 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 63 + local.get $0 + i64.clz + i32.wrap_i64 + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.tee $1 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + loop $while-continue|0 + local.get $1 + i32.const 2 + i32.ge_u + if + local.get $3 + local.get $1 + i32.const 2 + i32.sub + local.tee $1 + i32.const 1 + i32.shl + i32.add + local.get $0 + i32.wrap_i64 + i32.const 255 + i32.and + i32.const 2 + i32.shl + i32.const 16256 + i32.add + i32.load + i32.store + local.get $0 + i64.const 8 + i64.shr_u + local.set $0 + br $while-continue|0 + end + end + local.get $1 + i32.const 1 + i32.and + if + local.get $3 + local.get $0 + i32.wrap_i64 + i32.const 6 + i32.shl + i32.const 16256 + i32.add + i32.load16_u + i32.store16 + end + else + global.get $~lib/memory/__stack_pointer + block $__inlined_func$~lib/util/number/ulog_base$2264 (result i32) + local.get $0 + local.set $2 + local.get $1 + i32.popcnt + i32.const 1 + i32.eq + if + i32.const 63 + local.get $0 + i64.clz + i32.wrap_i64 + i32.sub + i32.const 31 + local.get $1 + i32.clz + i32.sub + i32.div_u + i32.const 1 + i32.add + br $__inlined_func$~lib/util/number/ulog_base$2264 + end + local.get $1 + i64.extend_i32_s + local.tee $5 + local.set $4 + i32.const 1 + local.set $3 + loop $while-continue|01 + local.get $2 + local.get $4 + i64.ge_u + if + local.get $2 + local.get $4 + i64.div_u + local.set $2 + local.get $4 + local.get $4 + i64.mul + local.set $4 + local.get $3 + i32.const 1 + i32.shl + local.set $3 + br $while-continue|01 + end + end + loop $while-continue|1 + local.get $2 + i64.const 0 + i64.ne + if + local.get $2 + local.get $5 + i64.div_u + local.set $2 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $while-continue|1 + end + end + local.get $3 + i32.const 1 + i32.sub + end + local.tee $6 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + local.get $3 + local.get $0 + local.get $6 + local.get $1 + call $~lib/util/number/utoa64_any_core + end + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/util/number/itoa64 (param $0 i64) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15824 + return + end + i64.const 0 + local.get $0 + i64.sub + local.get $0 + local.get $0 + i64.const 63 + i64.shr_u + i32.wrap_i64 + i32.const 1 + i32.shl + local.tee $1 + select + local.tee $0 + i64.const 4294967295 + i64.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.wrap_i64 + local.tee $4 + i32.const 100000 + i32.lt_u + if (result i32) + local.get $4 + i32.const 100 + i32.lt_u + if (result i32) + local.get $4 + i32.const 10 + i32.ge_u + i32.const 1 + i32.add + else + local.get $4 + i32.const 10000 + i32.ge_u + i32.const 3 + i32.add + local.get $4 + i32.const 1000 + i32.ge_u + i32.add + end + else + local.get $4 + i32.const 10000000 + i32.lt_u + if (result i32) + local.get $4 + i32.const 1000000 + i32.ge_u + i32.const 6 + i32.add + else + local.get $4 + i32.const 1000000000 + i32.ge_u + i32.const 8 + i32.add + local.get $4 + i32.const 100000000 + i32.ge_u + i32.add + end + end + local.tee $3 + i32.const 1 + i32.shl + local.get $1 + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + local.get $1 + local.get $2 + i32.add + local.get $4 + local.get $3 + call $~lib/util/number/utoa32_dec_lut + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i64.const 1000000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 1000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 100000000000 + i64.ge_u + i32.const 10 + i32.add + local.get $0 + i64.const 10000000000 + i64.ge_u + i32.add + else + local.get $0 + i64.const 100000000000000 + i64.ge_u + i32.const 13 + i32.add + local.get $0 + i64.const 10000000000000 + i64.ge_u + i32.add + end + else + local.get $0 + i64.const 100000000000000000 + i64.lt_u + if (result i32) + local.get $0 + i64.const 10000000000000000 + i64.ge_u + i32.const 16 + i32.add + else + local.get $0 + i64.const -8446744073709551616 + i64.ge_u + i32.const 18 + i32.add + local.get $0 + i64.const 1000000000000000000 + i64.ge_u + i32.add + end + end + local.tee $3 + i32.const 1 + i32.shl + local.get $1 + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store + local.get $1 + local.get $2 + i32.add + local.get $0 + local.get $3 + call $~lib/util/number/utoa64_dec_lut + end + local.get $1 + if + local.get $2 + i32.const 45 + i32.store16 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $export:assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $assembly/index/disassemble + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/index/runProgram (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $__inlined_func$assembly/index/runProgram$2441 + local.get $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + call $assembly/api-generic/VmInput#constructor + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $2 + local.get $1 + i32.store + local.get $2 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i64.const 10000 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $2 + local.get $0 + i32.store offset=16 + local.get $2 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.const 1 + i32.const 0 + call $assembly/api-generic/runVm + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 19248 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + local.get $0 + i32.load + call $~lib/number/I32#toString + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + i32.const 19248 + local.get $1 + call $~lib/string/String#concat + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$assembly/index/runProgram$2441 + end + local.get $2 + i32.const 1 + i32.eq + if + i32.const 20224 + i32.const 20304 + i32.const 57 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 18608 + i32.store offset=4 + local.get $2 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 18608 + local.get $0 + call $~lib/string/String#concat + i32.const 20304 + i32.const 60 + i32.const 3 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api-generic/runVm@varargs (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $1 + end + i32.const 0 + local.set $2 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $assembly/api-generic/runVm + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api-generic/getAssembly (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/api-generic/getAssembly + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $assembly/program-build/buildMask + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i64.extend_i32_s + call $assembly/codec/encodeVarU32 + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + i32.const 2 + i32.add + local.get $2 + i32.add + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.get $2 + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + i32.const 2 + local.set $2 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $6 + local.get $2 + local.get $5 + local.get $4 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 1 + i32.add + local.set $2 + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + local.get $6 + local.get $2 + local.get $0 + local.get $1 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 1 + i32.add + local.set $2 + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|1 + end + end + i32.const 0 + local.set $0 + loop $for-loop|2 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.get $0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $6 + local.get $2 + local.get $3 + local.get $0 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 1 + i32.add + local.set $2 + local.get $0 + i32.const 1 + i32.add + local.set $0 + br $for-loop|2 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api/resetGeneric (param $0 i32) (param $1 i32) (param $2 i64) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $assembly/program/liftBytes + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/program/deblob + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 13 + call $~lib/staticarray/StaticArray#constructor + local.tee $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + call $assembly/api/fillRegisters + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 2 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + call $assembly/memory/MemoryBuilder#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + call $assembly/memory/MemoryBuilder#build + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + local.get $3 + local.get $0 + local.get $1 + call $assembly/interpreter/Interpreter#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 + i32.store + local.get $1 + local.get $2 + call $assembly/gas/GasCounter#set@override + local.get $0 + global.set $assembly/api/interpreter + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + if + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $0 + local.get $1 + local.get $2 + local.get $3 + local.get $4 + call $assembly/api/resetGenericWithMemory + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api/setRegisters (param $0 i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 134 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $1 + local.get $0 + call $assembly/api/fillRegisters + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api/setMemory (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21300 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api/interpreter + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.eqz + if + i32.const 10512 + i32.const 20816 + i32.const 155 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $0 + i32.add + local.set $4 + local.get $0 + local.set $2 + loop $for-loop|0 + local.get $2 + local.get $4 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $5 + local.get $2 + local.get $1 + local.get $2 + local.get $0 + i32.sub + call $~lib/typedarray/Uint8Array#__get + call $assembly/memory/Memory#setU8 + drop + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54096 + i32.const 54144 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) +) diff --git a/build/test.d.ts b/build/test.d.ts new file mode 100644 index 0000000..981d658 --- /dev/null +++ b/build/test.d.ts @@ -0,0 +1,6 @@ +/** Exported memory */ +export declare const memory: WebAssembly.Memory; +/** + * assembly/test-run/runAllTests + */ +export declare function runAllTests(): void; diff --git a/build/test.js b/build/test.js new file mode 100644 index 0000000..7e2eb90 --- /dev/null +++ b/build/test.js @@ -0,0 +1,47 @@ +async function instantiate(module, imports = {}) { + const adaptedImports = { + env: Object.setPrototypeOf({ + abort(message, fileName, lineNumber, columnNumber) { + // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void + message = __liftString(message >>> 0); + fileName = __liftString(fileName >>> 0); + lineNumber = lineNumber >>> 0; + columnNumber = columnNumber >>> 0; + (() => { + // @external.js + throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); + })(); + }, + "console.log"(text) { + // ~lib/bindings/dom/console.log(~lib/string/String) => void + text = __liftString(text >>> 0); + console.log(text); + }, + }, Object.assign(Object.create(globalThis), imports.env || {})), + }; + const { exports } = await WebAssembly.instantiate(module, adaptedImports); + const memory = exports.memory || imports.env.memory; + function __liftString(pointer) { + if (!pointer) return null; + const + end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, + memoryU16 = new Uint16Array(memory.buffer); + let + start = pointer >>> 1, + string = ""; + while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); + return string + String.fromCharCode(...memoryU16.subarray(start, end)); + } + return exports; +} +export const { + memory, + runAllTests, +} = await (async url => instantiate( + await (async () => { + const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); + if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } + else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } + })(), { + } +))(new URL("test.wasm", import.meta.url)); diff --git a/build/test.wasm b/build/test.wasm new file mode 100644 index 0000000000000000000000000000000000000000..c893f4016987ad4e9d4a65e843c78c478f6a08af GIT binary patch literal 189597 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 LesDH?H17WaNe@@g literal 0 HcmV?d00001 diff --git a/build/test.wasm.map b/build/test.wasm.map new file mode 100644 index 0000000..af2d1b3 --- /dev/null +++ b/build/test.wasm.map @@ -0,0 +1 @@ +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/bit.test.ts","~lib/util/hash.ts","~lib/map.ts","~lib/array.ts","assembly/test.ts","~lib/number.ts","~lib/string.ts","assembly/instructions/branch.ts","assembly/instructions/branch.test.ts","assembly/instructions/logic.ts","assembly/instructions/logic.test.ts","assembly/instructions/math.ts","assembly/instructions/math.test.ts","assembly/instructions/rot.ts","assembly/instructions/rot.test.ts","assembly/memory.test.ts","~lib/util/bytes.ts","~lib/console.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","assembly/instructions/mov.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions/misc.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/instructions.ts","assembly/program.ts","assembly/program.test.ts","assembly/spi.ts","assembly/spi.test.ts","assembly/test-run.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./test","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2dad002dad00?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16;\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = SEGMENT_SIZE;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport {\n count_set_bits_32,\n count_set_bits_64,\n leading_zero_bits_32,\n leading_zero_bits_64,\n reverse_bytes,\n sign_extend_8,\n sign_extend_16,\n trailing_zero_bits_32,\n trailing_zero_bits_64,\n zero_extend_16,\n} from \"./bit\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"count_set_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 2 * 8 + 4);\n return assert;\n }),\n test(\"count_set_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 4);\n return assert;\n }),\n test(\"leading_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 16);\n return assert;\n }),\n test(\"leading_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 19);\n return assert;\n }),\n test(\"trailing_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 36);\n return assert;\n }),\n test(\"trailing_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 32);\n return assert;\n }),\n test(\"sign_extend_8\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_8(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_ffef);\n return assert;\n }),\n test(\"sign_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_beef);\n return assert;\n }),\n test(\"zero_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = zero_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0x0000_beef);\n return assert;\n }),\n test(\"reverse_bytes\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_dead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = reverse_bytes(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xefbe_adde_f0ff_0000);\n return assert;\n }),\n];\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","export class Test {\n constructor(\n public name: string,\n public ptr: (assert: Assert) => Assert,\n ) {}\n}\n\nexport class Assert {\n public isOkay: boolean = true;\n public errors: string[] = [];\n\n static todo(): Assert {\n const r = new Assert();\n r.fail(\"Not implemented yet!\");\n return r;\n }\n\n fail(msg: string): void {\n this.isOkay = false;\n this.errors.push(msg);\n }\n\n isArrayEqual(actual: T[], expected: T[], msg: string = \"\"): void {\n this.isEqual(actual.length, expected.length, `length @ ${msg}`);\n this.isEqual(actual.join(\",\").toString(), expected.join(\",\").toString(), msg);\n }\n\n isEqual(actual: T, expected: T, msg: string = \"\"): void {\n if (actual !== expected) {\n this.isOkay = false;\n const actualDisplay = isInteger(actual) ? `${actual} (0x${actual.toString(16)})` : `${actual}`;\n const expectDisplay = isInteger(expected) ? `${expected} (0x${expected.toString(16)})` : `${expected}`;\n this.errors.push(`Got: '${actualDisplay}', expected: '${expectDisplay}' @ ${msg}`);\n }\n }\n}\n\nexport function test(name: string, ptr: (assert: Assert) => Assert): Test {\n return new Test(name, ptr);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { branch_eq_imm } from \"./branch\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"branch_eq_imm\", () => {\n // when\n const args = new Args();\n args.a = 0;\n args.b = 0xfe;\n args.c = 0xdeadbeef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfe;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = branch_eq_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.StaticJump, \"outcome\");\n assert.isEqual(ret.staticJump, 0xdeadbeef, \"staticJump\");\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { and_inv, or_inv, xnor } from \"./logic\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"and_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = and_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_f000_0000_0000);\n return assert;\n }),\n test(\"or_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = or_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fff1);\n return assert;\n }),\n test(\"xnor\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0000;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = xnor(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_0fff_ffff_fff0);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport * as math from \"./math\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"max\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"max_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"add_32\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = 2 ** 64 - 1;\n regs[reg(args.b)] = 2 ** 64 - 1;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.add_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fffe);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { Outcome } from \"./outcome\";\nimport { rot_l_32, rot_l_64, rot_r_64_imm, rot_r_64_imm_alt } from \"./rot\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"rot_r_64_imm\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xef00_0000_00de_adbe);\n return assert;\n }),\n test(\"rot_r_64_imm_alt\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0xdead_beef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm_alt(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xefff_ffff_ffde_adbe);\n return assert;\n }),\n test(\"rot_l_64\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_00de_adbe_ef00);\n return assert;\n }),\n test(\"rot_l_32\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_adbe_efde);\n return assert;\n }),\n];\n","import { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY, RESERVED_PAGES } from \"./memory-page\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"Show fail when accessing any of the initial 16 pages\", () => {\n const mem = new MemoryBuilder().build();\n\n const a = mem.getI8(0);\n const b = mem.getU64(RESERVED_MEMORY - 1);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, true, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.fault.fault, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 61440);\n return assert;\n }),\n test(\"Show fail on missing page or invalid access\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Read, RESERVED_MEMORY, new Uint8Array(10));\n const mem = builder.build();\n\n const a = mem.getU64(RESERVED_MEMORY);\n const b = mem.getU8((RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT);\n const c = mem.setU8(RESERVED_MEMORY, 12);\n const d = mem.getU8(RESERVED_MEMORY);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, false, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.ok, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 69632);\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, true, \"c.access\");\n assert.isEqual(c.fault, 65536);\n assert.isEqual(d.ok, 0);\n return assert;\n }),\n test(\"should read and write across pages\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Write, RESERVED_MEMORY, new Uint8Array(1));\n builder.setData(Access.Write, (RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT, new Uint8Array(1));\n const mem = builder.build();\n\n const out = new Uint8Array(16);\n const data = new Uint8Array(out.length);\n data.set([0xde, 0xad, 0xbe, 0xef], 0);\n\n const a = mem.bytesWrite(RESERVED_MEMORY + PAGE_SIZE - 10, data);\n const b = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE - 9, out);\n const c = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE * 2, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(a.isAccess, false, \"a.access\");\n assert.isEqual(a.fault, 0, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(b.isAccess, false, \"b.access\");\n assert.isEqual(b.fault, 0, \"b.fault\");\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, false, \"c.access\");\n assert.isEqual(out.toString(), \"173,190,239,0,0,0,0,0,0,0,0,0,0,0,0,0\");\n assert.isEqual(data.toString(), \"222,173,190,239,0,0,0,0,0,0,0,0,0,0,0,0\");\n return assert;\n }),\n test(\"should allow 0-bytes reads and writes everywhere\", () => {\n const mem = new MemoryBuilder().setData(Access.Read, RESERVED_MEMORY, new Uint8Array(0)).build();\n\n const out = new Uint8Array(0);\n\n // reserved pages\n const a = mem.bytesRead(0, out);\n const b = mem.bytesWrite(0, out);\n\n // not allocated\n const c = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n const d = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n\n // readable page\n const e = mem.bytesWrite(RESERVED_MEMORY, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(c.isFault, false, \"c.fault\");\n assert.isEqual(d.isFault, false, \"d.fault\");\n assert.isEqual(e.isFault, false, \"e.fault\");\n return assert;\n }),\n];\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { Arguments } from \"./arguments\";\nimport { RUN } from \"./instructions-exe\";\nimport { jump_ind } from \"./instructions/jump\";\nimport { trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport { BasicBlocks, JumpTable, Mask, deblob, decodeArguments } from \"./program\";\nimport { Assert, Test, test } from \"./test\";\n\nexport function u8arr(data: number[]): Uint8Array {\n const ret = new Uint8Array(data.length);\n ret.set(data, 0);\n return ret;\n}\n\nexport const TESTS: Test[] = [\n test(\"should parse packed mask correctly\", () => {\n const mask = new Mask(u8arr([0b0001_0000, 0b1000_0000, 0b1111_1000]), 21);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [4, 3, 2, 1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 3, 2, 1, 0, 0],\n );\n\n assert.isEqual(mask.isInstruction(0), false);\n assert.isEqual(mask.isInstruction(4), true);\n\n assert.isEqual(mask.skipBytesToNextInstruction(20), 0);\n assert.isEqual(mask.skipBytesToNextInstruction(22), 0);\n return assert;\n }),\n\n test(\"should not allow skipping more than 24 bytes\", () => {\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [\n 0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,\n 1, 0,\n ],\n );\n return assert;\n }),\n\n test(\"should decode arguments correctly\", () => {\n const data = u8arr([0xff, 0xff, 0xff, 0xff]);\n const args = decodeArguments(Arguments.OneImm, data, 4);\n\n const assert = new Assert();\n assert.isEqual(args.a, -1, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should decode positive bounded by skip\", () => {\n const data = u8arr([0x05, 0x05]);\n const args = decodeArguments(Arguments.OneImm, data, 1);\n\n const assert = new Assert();\n assert.isEqual(args.a, 5, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should deblob program\", () => {\n const raw = u8arr([\n 0, 0, 33, 51, 8, 1, 51, 9, 1, 40, 3, 0, 149, 119, 255, 81, 7, 12, 100, 138, 200, 152, 8, 100, 169, 40, 243, 100,\n 135, 51, 8, 51, 9, 1, 50, 0, 73, 147, 82, 213, 0,\n ]);\n const program = deblob(raw);\n const assert = new Assert();\n assert.isEqual(\n program.mask.toString(),\n \"Mask[0, 2, 1, 0, 2, 1, 0, 1, 0, 0, 2, 1, 0, 2, 1, 0, 1, 0, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, ]\",\n );\n assert.isEqual(program.jumpTable.toString(), \"JumpTable[]\");\n assert.isEqual(\n program.basicBlocks.toString(),\n \"BasicBlocks[0 -> start, 6 -> end, 8 -> startend, 9 -> start, 12 -> end, 15 -> start, 22 -> end, 24 -> start, 30 -> end, 31 -> startend, ]\",\n );\n return assert;\n }),\n\n test(\"should construct basic blocks correctly based on skip\", () => {\n const code = u8arr([\n opcode(trap),\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n opcode(jump_ind),\n ]);\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n const basicBlocks = new BasicBlocks(code, mask);\n const assert = new Assert();\n assert.isEqual(\n mask.toString(),\n \"Mask[0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, ]\",\n );\n assert.isEqual(basicBlocks.toString(), \"BasicBlocks[0 -> startend, 26 -> start, 31 -> end, ]\");\n return assert;\n }),\n test(\"should parse jump table with large numbers\", () => {\n const jumpTable = new JumpTable(\n 10,\n u8arr([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 2, 2, 2, 0]),\n );\n const assert = new Assert();\n assert.isEqual(\n jumpTable.toString(),\n \"JumpTable[0 -> 18446744073709551615, 1 -> 18446744073709551615, 2 -> 18446744073709551615, ]\",\n );\n return assert;\n }),\n];\n\nfunction opcode(search: InstructionRun): number {\n const idx = RUN.indexOf(search);\n if (idx < 0) {\n throw new Error(\"Opcode not found in RUN table for instruction\");\n }\n return idx;\n}\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { Program, deblob } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const DATA_LENGTH: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - DATA_LENGTH;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = 2 ** 32 - 2 * SEGMENT_SIZE - DATA_LENGTH;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > DATA_LENGTH) {\n throw new Error(\"Arguments length too big\");\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { liftBytes } from \"./program\";\nimport { decodeSpi } from \"./spi\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"should decode standard program\", () => {\n const PROGRAM = liftBytes([\n 0x04, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0xab, 0xcd, 0xef, 0x01, 0x12, 0x34, 0x07, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x03, 0xc8, 0x87, 0x09, 0x01,\n ]);\n const ARGS = liftBytes([0x12, 0x34, 0x56]);\n\n const spi = decodeSpi(PROGRAM, ARGS);\n\n const assert = new Assert();\n assert.isEqual(\n spi.toString(),\n \"StandardProgram { program: Program { code: 200,135,9, mask: Mask[0, 2, 1, ], jumpTable: JumpTable[], basicBlocks: BasicBlocks[0 -> start, ] }, memory_pages: 7, registers: 4294901760,4278059008,0,0,0,0,0,4278124544,3,0,0,0,0 }\",\n );\n return assert;\n }),\n];\n","import * as bit from \"./instructions/bit.test\";\nimport * as branch from \"./instructions/branch.test\";\nimport * as logic from \"./instructions/logic.test\";\nimport * as math from \"./instructions/math.test\";\nimport * as rot from \"./instructions/rot.test\";\nimport * as memory from \"./memory.test\";\nimport * as program from \"./program.test\";\nimport * as spi from \"./spi.test\";\nimport { Assert, Test } from \"./test\";\n\nexport function runAllTests(): void {\n let a: u64 = 0;\n\n a += run(bit.TESTS, \"bit.ts\");\n a += run(branch.TESTS, \"branch.ts\");\n a += run(logic.TESTS, \"logic.ts\");\n a += run(math.TESTS, \"math.ts\");\n a += run(memory.TESTS, \"memory.ts\");\n a += run(program.TESTS, \"program.ts\");\n a += run(rot.TESTS, \"rot.ts\");\n a += run(spi.TESTS, \"spi.ts\");\n\n const okay = u32(a >> 32);\n const total = u32(a);\n\n printSummary(\"\\n\\nTotal\", okay, total);\n if (okay !== total) {\n throw new Error(\"Some tests failed.\");\n }\n}\n\nfunction run(tests: Test[], file: string): u64 {\n let ok = 0;\n console.log(`> ${file}`);\n for (let i = 0; i < tests.length; i++) {\n console.log(` >>> ${tests[i].name}`);\n const res = tests[i].ptr(new Assert());\n if (res.isOkay) {\n console.log(` <<< ${tests[i].name} ✅`);\n ok += 1;\n } else {\n for (let j = 0; j < res.errors.length; j++) {\n console.log(` ${res.errors[j]}`);\n }\n console.log(` <<< ${tests[i].name} 🔴`);\n }\n }\n\n printSummary(`< ${file}`, ok, tests.length);\n\n return (u64(ok) << 32) + tests.length;\n}\n\nfunction printSummary(msg: string, okay: u32, total: u32): void {\n const ico = okay === total ? \"✅\" : \"🔴\";\n console.log(`${msg} ${okay} / ${total} ${ico}`);\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/test.wat b/build/test.wat new file mode 100644 index 0000000..c8dd9d6 --- /dev/null +++ b/build/test.wat @@ -0,0 +1,45369 @@ +(module + (type $0 (func (param i32) (result i32))) + (type $1 (func (param i32 i32 i32) (result i32))) + (type $2 (func (param i32 i32))) + (type $3 (func (param i32 i32) (result i32))) + (type $4 (func)) + (type $5 (func (param i32 i32 i32))) + (type $6 (func (param i32 i32 i32 i32) (result i32))) + (type $7 (func (param i32))) + (type $8 (func (param i32 i32 i32 i32))) + (type $9 (func (param i64 i64) (result i64))) + (type $10 (func (param i64 i32) (result i32))) + (type $11 (func (result i32))) + (type $12 (func (param i32) (result i64))) + (type $13 (func (param i32 i64))) + (type $14 (func (param i32 i32 i64) (result i32))) + (type $15 (func (param i64) (result i32))) + (type $16 (func (param i32 i32 i64))) + (type $17 (func (param i32 i64 i32))) + (type $18 (func (param i32 i32 i32 i32 i32) (result i32))) + (type $19 (func (param i32 i32) (result i64))) + (type $20 (func (param i32 i64 i64 i32))) + (type $21 (func (param i64) (result i64))) + (type $22 (func (param i32 i64 i32 i32))) + (type $23 (func (param i32 i32 i32 i32 i32))) + (type $24 (func (param i32 i32 i64 i32) (result i32))) + (type $25 (func (param i32 i64) (result i32))) + (type $26 (func (param i32) (result f64))) + (type $27 (func (param i32 i32 f64))) + (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) + (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) + (global $assembly/arguments/Arguments.Zero i32 (i32.const 0)) + (global $assembly/arguments/Arguments.OneImm i32 (i32.const 1)) + (global $assembly/arguments/Arguments.TwoImm i32 (i32.const 2)) + (global $assembly/arguments/Arguments.OneOff i32 (i32.const 3)) + (global $assembly/arguments/Arguments.OneRegOneImm i32 (i32.const 4)) + (global $assembly/arguments/Arguments.OneRegOneExtImm i32 (i32.const 5)) + (global $assembly/arguments/Arguments.OneRegTwoImm i32 (i32.const 6)) + (global $assembly/arguments/Arguments.OneRegOneImmOneOff i32 (i32.const 7)) + (global $assembly/arguments/Arguments.TwoReg i32 (i32.const 8)) + (global $assembly/arguments/Arguments.TwoRegOneImm i32 (i32.const 9)) + (global $assembly/arguments/Arguments.TwoRegOneOff i32 (i32.const 10)) + (global $assembly/arguments/Arguments.TwoRegTwoImm i32 (i32.const 11)) + (global $assembly/arguments/Arguments.ThreeReg i32 (i32.const 12)) + (global $assembly/arguments/RELEVANT_ARGS i32 (i32.const 112)) + (global $assembly/arguments/REQUIRED_BYTES i32 (i32.const 240)) + (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) + (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) + (global $~lib/shared/runtime/Runtime.Stub i32 (i32.const 0)) + (global $~lib/shared/runtime/Runtime.Minimal i32 (i32.const 1)) + (global $~lib/shared/runtime/Runtime.Incremental i32 (i32.const 2)) + (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) + (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) + (global $~lib/native/ASC_LOW_MEMORY_LIMIT i32 (i32.const 0)) + (global $~lib/builtins/i32.MAX_VALUE i32 (i32.const 2147483647)) + (global $~argumentsLength (mut i32) (i32.const 0)) + (global $assembly/arguments/DECODERS i32 (i32.const 1248)) + (global $assembly/registers/NO_OF_REGISTERS i32 (i32.const 13)) + (global $assembly/registers/REG_SIZE_BYTES i32 (i32.const 8)) + (global $assembly/memory-page/PAGE_SIZE i32 (i32.const 4096)) + (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) + (global $~lib/native/ASC_SHRINK_LEVEL i32 (i32.const 0)) + (global $assembly/memory-page/SEGMENT_SIZE (mut i32) (i32.const 0)) + (global $assembly/memory-page/SEGMENT_SIZE_SHIFT i32 (i32.const 16)) + (global $assembly/memory-page/RESERVED_MEMORY (mut i32) (i32.const 0)) + (global $assembly/memory-page/RESERVED_PAGES (mut i32) (i32.const 0)) + (global $assembly/memory-page/ALLOCATE_EAGERLY (mut i32) (i32.const 0)) + (global $assembly/memory-page/Access.None i32 (i32.const 0)) + (global $assembly/memory-page/Access.Read i32 (i32.const 1)) + (global $assembly/memory-page/Access.Write i32 (i32.const 2)) + (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) + (global $assembly/memory/MEMORY_SIZE i64 (i64.const 4294967296)) + (global $~lib/native/ASC_RUNTIME i32 (i32.const 2)) + (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) + (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) + (global $assembly/instructions/outcome/Result.PANIC i32 (i32.const 0)) + (global $assembly/instructions/outcome/Result.FAULT i32 (i32.const 1)) + (global $assembly/instructions/outcome/Result.FAULT_ACCESS i32 (i32.const 2)) + (global $assembly/instructions/outcome/Result.HOST i32 (i32.const 3)) + (global $assembly/instructions/outcome/Outcome.Ok i32 (i32.const 0)) + (global $assembly/instructions/outcome/Outcome.StaticJump i32 (i32.const 1)) + (global $assembly/instructions/outcome/Outcome.DynamicJump i32 (i32.const 2)) + (global $assembly/instructions/outcome/Outcome.Result i32 (i32.const 3)) + (global $assembly/instructions/bit/count_set_bits_64 i32 (i32.const 1472)) + (global $assembly/instructions/bit/count_set_bits_32 i32 (i32.const 1504)) + (global $assembly/instructions/bit/leading_zero_bits_64 i32 (i32.const 1536)) + (global $assembly/instructions/bit/leading_zero_bits_32 i32 (i32.const 1568)) + (global $assembly/instructions/bit/trailing_zero_bits_64 i32 (i32.const 1600)) + (global $assembly/instructions/bit/trailing_zero_bits_32 i32 (i32.const 1632)) + (global $assembly/instructions/bit/sign_extend_8 i32 (i32.const 1664)) + (global $assembly/instructions/bit/sign_extend_16 i32 (i32.const 1696)) + (global $assembly/instructions/bit/zero_extend_16 i32 (i32.const 1728)) + (global $assembly/instructions/bit/reverse_bytes i32 (i32.const 1760)) + (global $~lib/builtins/u32.MAX_VALUE i32 (i32.const -1)) + (global $assembly/instructions/bit.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/instructions/branch/branch_eq_imm i32 (i32.const 5440)) + (global $assembly/instructions/branch/branch_ne_imm i32 (i32.const 5472)) + (global $assembly/instructions/branch/branch_lt_u_imm i32 (i32.const 5504)) + (global $assembly/instructions/branch/branch_le_u_imm i32 (i32.const 5536)) + (global $assembly/instructions/branch/branch_ge_u_imm i32 (i32.const 5568)) + (global $assembly/instructions/branch/branch_gt_u_imm i32 (i32.const 5600)) + (global $assembly/instructions/branch/branch_lt_s_imm i32 (i32.const 5632)) + (global $assembly/instructions/branch/branch_le_s_imm i32 (i32.const 5664)) + (global $assembly/instructions/branch/branch_ge_s_imm i32 (i32.const 5696)) + (global $assembly/instructions/branch/branch_gt_s_imm i32 (i32.const 5728)) + (global $assembly/instructions/branch/branch_eq i32 (i32.const 5760)) + (global $assembly/instructions/branch/branch_ne i32 (i32.const 5792)) + (global $assembly/instructions/branch/branch_lt_u i32 (i32.const 5824)) + (global $assembly/instructions/branch/branch_lt_s i32 (i32.const 5856)) + (global $assembly/instructions/branch/branch_ge_u i32 (i32.const 5888)) + (global $assembly/instructions/branch/branch_ge_s i32 (i32.const 5920)) + (global $assembly/instructions/branch.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/instructions/logic/and_imm i32 (i32.const 6224)) + (global $assembly/instructions/logic/xor_imm i32 (i32.const 6256)) + (global $assembly/instructions/logic/or_imm i32 (i32.const 6288)) + (global $assembly/instructions/logic/and i32 (i32.const 6320)) + (global $assembly/instructions/logic/xor i32 (i32.const 6352)) + (global $assembly/instructions/logic/or i32 (i32.const 6384)) + (global $assembly/instructions/logic/and_inv i32 (i32.const 6416)) + (global $assembly/instructions/logic/or_inv i32 (i32.const 6448)) + (global $assembly/instructions/logic/xnor i32 (i32.const 6480)) + (global $assembly/instructions/logic.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/instructions/math/add_imm_32 i32 (i32.const 6720)) + (global $assembly/instructions/math/mul_imm_32 i32 (i32.const 6752)) + (global $assembly/instructions/math/neg_add_imm_32 i32 (i32.const 6784)) + (global $assembly/instructions/math/add_imm i32 (i32.const 6816)) + (global $assembly/instructions/math/mul_imm i32 (i32.const 6848)) + (global $assembly/instructions/math/neg_add_imm i32 (i32.const 6880)) + (global $assembly/instructions/math/add_32 i32 (i32.const 6912)) + (global $assembly/instructions/math/sub_32 i32 (i32.const 6944)) + (global $assembly/instructions/math/mul_32 i32 (i32.const 6976)) + (global $~lib/builtins/u64.MAX_VALUE i64 (i64.const -1)) + (global $assembly/instructions/math/div_u_32 i32 (i32.const 7008)) + (global $~lib/builtins/i32.MIN_VALUE i32 (i32.const -2147483648)) + (global $assembly/instructions/math/div_s_32 i32 (i32.const 7040)) + (global $assembly/instructions/math/rem_u_32 i32 (i32.const 7072)) + (global $assembly/instructions/math/rem_s_32 i32 (i32.const 7104)) + (global $assembly/instructions/math/add_64 i32 (i32.const 7136)) + (global $assembly/instructions/math/sub i32 (i32.const 7168)) + (global $assembly/instructions/math/mul i32 (i32.const 7200)) + (global $assembly/instructions/math/div_u i32 (i32.const 7232)) + (global $~lib/builtins/i64.MIN_VALUE i64 (i64.const -9223372036854775808)) + (global $assembly/instructions/math/div_s i32 (i32.const 7264)) + (global $assembly/instructions/math/rem_u i32 (i32.const 7296)) + (global $assembly/instructions/math/rem_s i32 (i32.const 7328)) + (global $assembly/instructions/math/mul_upper_s_s i32 (i32.const 7360)) + (global $assembly/instructions/math/mul_upper_u_u i32 (i32.const 7392)) + (global $assembly/instructions/math/mul_upper_s_u i32 (i32.const 7424)) + (global $assembly/instructions/math/max i32 (i32.const 7456)) + (global $assembly/instructions/math/max_u i32 (i32.const 7488)) + (global $assembly/instructions/math/min i32 (i32.const 7520)) + (global $assembly/instructions/math/min_u i32 (i32.const 7552)) + (global $assembly/instructions/math.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/instructions/rot/rot_r_64_imm i32 (i32.const 7904)) + (global $assembly/instructions/rot/rot_r_64_imm_alt i32 (i32.const 7936)) + (global $assembly/instructions/rot/rot_r_32_imm i32 (i32.const 7968)) + (global $assembly/instructions/rot/rot_r_32_imm_alt i32 (i32.const 8000)) + (global $assembly/instructions/rot/rot_l_64 i32 (i32.const 8032)) + (global $assembly/instructions/rot/rot_l_32 i32 (i32.const 8064)) + (global $assembly/instructions/rot/rot_r_64 i32 (i32.const 8096)) + (global $assembly/instructions/rot/rot_r_32 i32 (i32.const 8128)) + (global $assembly/instructions/rot.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/memory.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/instructions/jump/jump i32 (i32.const 10576)) + (global $assembly/instructions/jump/jump_ind i32 (i32.const 10608)) + (global $assembly/instructions/jump/load_imm_jump i32 (i32.const 10640)) + (global $assembly/instructions/jump/load_imm_jump_ind i32 (i32.const 10672)) + (global $assembly/instructions/load/load_imm_64 i32 (i32.const 10704)) + (global $assembly/instructions/load/load_imm i32 (i32.const 10736)) + (global $assembly/instructions/load/load_u8 i32 (i32.const 10768)) + (global $assembly/instructions/load/load_i8 i32 (i32.const 10800)) + (global $assembly/instructions/load/load_u16 i32 (i32.const 10832)) + (global $assembly/instructions/load/load_i16 i32 (i32.const 10864)) + (global $assembly/instructions/load/load_u32 i32 (i32.const 10896)) + (global $assembly/instructions/load/load_i32 i32 (i32.const 10928)) + (global $assembly/instructions/load/load_u64 i32 (i32.const 10960)) + (global $assembly/instructions/load/load_ind_u8 i32 (i32.const 10992)) + (global $assembly/instructions/load/load_ind_i8 i32 (i32.const 11024)) + (global $assembly/instructions/load/load_ind_u16 i32 (i32.const 11056)) + (global $assembly/instructions/load/load_ind_i16 i32 (i32.const 11088)) + (global $assembly/instructions/load/load_ind_u32 i32 (i32.const 11120)) + (global $assembly/instructions/load/load_ind_i32 i32 (i32.const 11152)) + (global $assembly/instructions/load/load_ind_u64 i32 (i32.const 11184)) + (global $assembly/instructions/mov/move_reg i32 (i32.const 11216)) + (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11248)) + (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11280)) + (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11312)) + (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11344)) + (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 11376)) + (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 11408)) + (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 11440)) + (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 11472)) + (global $assembly/instructions/set/set_lt_u i32 (i32.const 11504)) + (global $assembly/instructions/set/set_lt_s i32 (i32.const 11536)) + (global $assembly/instructions/shift/MAX_SHIFT_64 i32 (i32.const 64)) + (global $assembly/instructions/shift/MAX_SHIFT_32 i32 (i32.const 32)) + (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 11568)) + (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 11600)) + (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 11632)) + (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 11664)) + (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 11696)) + (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 11728)) + (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 11760)) + (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 11792)) + (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 11824)) + (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 11856)) + (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 11888)) + (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 11920)) + (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 11952)) + (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 11984)) + (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12016)) + (global $assembly/instructions/shift/shlo_l i32 (i32.const 12048)) + (global $assembly/instructions/shift/shlo_r i32 (i32.const 12080)) + (global $assembly/instructions/shift/shar_r i32 (i32.const 12112)) + (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12144)) + (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12176)) + (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12208)) + (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12240)) + (global $assembly/instructions/store/store_u8 i32 (i32.const 12272)) + (global $assembly/instructions/store/store_u16 i32 (i32.const 12304)) + (global $assembly/instructions/store/store_u32 i32 (i32.const 12336)) + (global $assembly/instructions/store/store_u64 i32 (i32.const 12368)) + (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 12400)) + (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 12432)) + (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 12464)) + (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 12496)) + (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 12528)) + (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 12560)) + (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 12592)) + (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 12624)) + (global $assembly/instructions/misc/INVALID i32 (i32.const 12656)) + (global $assembly/instructions/misc/trap i32 (i32.const 12688)) + (global $assembly/instructions/misc/fallthrough i32 (i32.const 12720)) + (global $assembly/instructions/misc/ecalli i32 (i32.const 12752)) + (global $assembly/instructions/misc/sbrk i32 (i32.const 12784)) + (global $assembly/instructions-exe/RUN i32 (i32.const 13760)) + (global $assembly/codec/MASKS i32 (i32.const 13840)) + (global $assembly/codec/variableLength i32 (i32.const 13888)) + (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) + (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) + (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) + (global $assembly/program/MAX_SKIP i32 (i32.const 24)) + (global $assembly/program/BasicBlock.NONE i32 (i32.const 0)) + (global $assembly/program/BasicBlock.START i32 (i32.const 2)) + (global $assembly/program/BasicBlock.END i32 (i32.const 4)) + (global $assembly/program.test/TESTS (mut i32) (i32.const 0)) + (global $assembly/spi/DATA_LENGTH (mut i32) (i32.const 0)) + (global $assembly/spi/ARGS_SEGMENT_START (mut i32) (i32.const 0)) + (global $assembly/spi/STACK_SEGMENT_END (mut i32) (i32.const 0)) + (global $assembly/spi.test/TESTS (mut i32) (i32.const 0)) + (global $~lib/rt/__rtti_base i32 (i32.const 27856)) + (global $~lib/memory/__data_end i32 (i32.const 28052)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 60820)) + (global $~lib/memory/__heap_base i32 (i32.const 60820)) + (memory $0 1) + (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") + (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $2 (i32.const 140) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") + (data $3 (i32.const 220) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00\a0\00\00\00\a0\00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $4 (i32.const 268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e\00\00\00\00\00") + (data $5 (i32.const 332) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $6 (i32.const 400) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $7 (i32.const 432) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $8 (i32.const 460) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e\00\00\00\00\00\00\00\00\00") + (data $9 (i32.const 524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $10 (i32.const 576) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $11 (i32.const 604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $12 (i32.const 668) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00") + (data $13 (i32.const 700) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $14 (i32.const 764) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") + (data $15 (i32.const 796) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") + (data $16 (i32.const 828) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\04\00\00\00\00\00\00\00\00\00\00\00") + (data $17 (i32.const 860) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\05\00\00\00\00\00\00\00\00\00\00\00") + (data $18 (i32.const 892) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\06\00\00\00\00\00\00\00\00\00\00\00") + (data $19 (i32.const 924) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\07\00\00\00\00\00\00\00\00\00\00\00") + (data $20 (i32.const 956) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00") + (data $21 (i32.const 988) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\t\00\00\00\00\00\00\00\00\00\00\00") + (data $22 (i32.const 1020) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") + (data $23 (i32.const 1052) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0b\00\00\00\00\00\00\00\00\00\00\00") + (data $24 (i32.const 1084) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0c\00\00\00\00\00\00\00\00\00\00\00") + (data $25 (i32.const 1116) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00") + (data $26 (i32.const 1148) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\b0\02\00\00\10\03\00\000\03\00\00P\03\00\00p\03\00\00\90\03\00\00\b0\03\00\00\d0\03\00\00\f0\03\00\00\10\04\00\000\04\00\00P\04\00\00p\04\00\00\00\00\00\00\00\00\00\00") + (data $27 (i32.const 1228) ",\00\00\00\00\00\00\00\00\00\00\00\07\00\00\00\10\00\00\00\90\04\00\00\90\04\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $28 (i32.const 1276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h\00") + (data $29 (i32.const 1324) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") + (data $30 (i32.const 1388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00") + (data $31 (i32.const 1452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\0e\00\00\00\00\00\00\00\00\00\00\00") + (data $32 (i32.const 1484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\0f\00\00\00\00\00\00\00\00\00\00\00") + (data $33 (i32.const 1516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\10\00\00\00\00\00\00\00\00\00\00\00") + (data $34 (i32.const 1548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\11\00\00\00\00\00\00\00\00\00\00\00") + (data $35 (i32.const 1580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\12\00\00\00\00\00\00\00\00\00\00\00") + (data $36 (i32.const 1612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\13\00\00\00\00\00\00\00\00\00\00\00") + (data $37 (i32.const 1644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\14\00\00\00\00\00\00\00\00\00\00\00") + (data $38 (i32.const 1676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\15\00\00\00\00\00\00\00\00\00\00\00") + (data $39 (i32.const 1708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\16\00\00\00\00\00\00\00\00\00\00\00") + (data $40 (i32.const 1740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\17\00\00\00\00\00\00\00\00\00\00\00") + (data $41 (i32.const 1772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00c\00o\00u\00n\00t\00_\00s\00e\00t\00_\00b\00i\00t\00s\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $42 (i32.const 1836) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $43 (i32.const 1868) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00") + (data $44 (i32.const 1916) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!\00\00\00\00\00\00\00") + (data $45 (i32.const 2028) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $46 (i32.const 2092) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $47 (i32.const 2124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00o\00u\00t\00c\00o\00m\00e\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $48 (i32.const 2172) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00(\000\00x\00\00\00\00\00") + (data $49 (i32.const 2204) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") + (data $50 (i32.const 2236) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $51 (i32.const 2284) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006\00\00\00\00\00\00\00\00\00") + (data $52 (i32.const 2412) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") + (data $53 (i32.const 2476) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\000\00\00\00\00\00\00\00\00\00\00\00") + (data $54 (i32.const 2508) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\00") + (data $55 (i32.const 2908) "\1c\04\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $56 (i32.const 3964) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z\00\00\00\00\00") + (data $57 (i32.const 4060) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $58 (i32.const 4092) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $59 (i32.const 4140) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00G\00o\00t\00:\00 \00\'\00") + (data $60 (i32.const 4172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00\'\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 \00\'\00") + (data $61 (i32.const 4220) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00\'\00 \00@\00 \00\00\00\00\00") + (data $62 (i32.const 4252) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $63 (i32.const 4300) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $64 (i32.const 4348) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $65 (i32.const 4396) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $66 (i32.const 4444) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\18\00\00\00\00\00\00\00\00\00\00\00") + (data $67 (i32.const 4476) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00c\00o\00u\00n\00t\00_\00s\00e\00t\00_\00b\00i\00t\00s\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $68 (i32.const 4540) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\19\00\00\00\00\00\00\00\00\00\00\00") + (data $69 (i32.const 4572) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00l\00e\00a\00d\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\006\004\00\00\00\00\00") + (data $70 (i32.const 4636) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1a\00\00\00\00\00\00\00\00\00\00\00") + (data $71 (i32.const 4668) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00l\00e\00a\00d\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\003\002\00\00\00\00\00") + (data $72 (i32.const 4732) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1b\00\00\00\00\00\00\00\00\00\00\00") + (data $73 (i32.const 4764) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00t\00r\00a\00i\00l\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\006\004\00\00\00") + (data $74 (i32.const 4828) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1c\00\00\00\00\00\00\00\00\00\00\00") + (data $75 (i32.const 4860) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00t\00r\00a\00i\00l\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\003\002\00\00\00") + (data $76 (i32.const 4924) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1d\00\00\00\00\00\00\00\00\00\00\00") + (data $77 (i32.const 4956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00s\00i\00g\00n\00_\00e\00x\00t\00e\00n\00d\00_\008\00\00\00") + (data $78 (i32.const 5004) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1e\00\00\00\00\00\00\00\00\00\00\00") + (data $79 (i32.const 5036) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00s\00i\00g\00n\00_\00e\00x\00t\00e\00n\00d\00_\001\006\00") + (data $80 (i32.const 5084) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1f\00\00\00\00\00\00\00\00\00\00\00") + (data $81 (i32.const 5116) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00z\00e\00r\00o\00_\00e\00x\00t\00e\00n\00d\00_\001\006\00") + (data $82 (i32.const 5164) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $83 (i32.const 5196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00r\00e\00v\00e\00r\00s\00e\00_\00b\00y\00t\00e\00s\00\00\00") + (data $84 (i32.const 5244) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $85 (i32.const 5292) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $86 (i32.const 5340) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $87 (i32.const 5388) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00!\00\00\00\00\00\00\00\00\00\00\00") + (data $88 (i32.const 5420) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\"\00\00\00\00\00\00\00\00\00\00\00") + (data $89 (i32.const 5452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00#\00\00\00\00\00\00\00\00\00\00\00") + (data $90 (i32.const 5484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00$\00\00\00\00\00\00\00\00\00\00\00") + (data $91 (i32.const 5516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00%\00\00\00\00\00\00\00\00\00\00\00") + (data $92 (i32.const 5548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00&\00\00\00\00\00\00\00\00\00\00\00") + (data $93 (i32.const 5580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\'\00\00\00\00\00\00\00\00\00\00\00") + (data $94 (i32.const 5612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") + (data $95 (i32.const 5644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") + (data $96 (i32.const 5676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00*\00\00\00\00\00\00\00\00\00\00\00") + (data $97 (i32.const 5708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00+\00\00\00\00\00\00\00\00\00\00\00") + (data $98 (i32.const 5740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") + (data $99 (i32.const 5772) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00-\00\00\00\00\00\00\00\00\00\00\00") + (data $100 (i32.const 5804) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00.\00\00\00\00\00\00\00\00\00\00\00") + (data $101 (i32.const 5836) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00/\00\00\00\00\00\00\00\00\00\00\00") + (data $102 (i32.const 5868) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\000\00\00\00\00\00\00\00\00\00\00\00") + (data $103 (i32.const 5900) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\001\00\00\00\00\00\00\00\00\00\00\00") + (data $104 (i32.const 5932) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00b\00r\00a\00n\00c\00h\00_\00e\00q\00_\00i\00m\00m\00\00\00") + (data $105 (i32.const 5980) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00s\00t\00a\00t\00i\00c\00J\00u\00m\00p\00\00\00\00\00\00\00\00\00") + (data $106 (i32.const 6028) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $107 (i32.const 6076) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $108 (i32.const 6124) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $109 (i32.const 6172) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\002\00\00\00\00\00\00\00\00\00\00\00") + (data $110 (i32.const 6204) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\003\00\00\00\00\00\00\00\00\00\00\00") + (data $111 (i32.const 6236) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\004\00\00\00\00\00\00\00\00\00\00\00") + (data $112 (i32.const 6268) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\005\00\00\00\00\00\00\00\00\00\00\00") + (data $113 (i32.const 6300) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\006\00\00\00\00\00\00\00\00\00\00\00") + (data $114 (i32.const 6332) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\007\00\00\00\00\00\00\00\00\00\00\00") + (data $115 (i32.const 6364) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\008\00\00\00\00\00\00\00\00\00\00\00") + (data $116 (i32.const 6396) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\009\00\00\00\00\00\00\00\00\00\00\00") + (data $117 (i32.const 6428) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00:\00\00\00\00\00\00\00\00\00\00\00") + (data $118 (i32.const 6460) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00;\00\00\00\00\00\00\00\00\00\00\00") + (data $119 (i32.const 6492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00a\00n\00d\00_\00i\00n\00v\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $120 (i32.const 6540) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00<\00\00\00\00\00\00\00\00\00\00\00") + (data $121 (i32.const 6572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00o\00r\00_\00i\00n\00v\00") + (data $122 (i32.const 6604) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00=\00\00\00\00\00\00\00\00\00\00\00") + (data $123 (i32.const 6636) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00x\00n\00o\00r\00\00\00\00\00") + (data $124 (i32.const 6668) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00>\00\00\00\00\00\00\00\00\00\00\00") + (data $125 (i32.const 6700) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00?\00\00\00\00\00\00\00\00\00\00\00") + (data $126 (i32.const 6732) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00@\00\00\00\00\00\00\00\00\00\00\00") + (data $127 (i32.const 6764) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00A\00\00\00\00\00\00\00\00\00\00\00") + (data $128 (i32.const 6796) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00B\00\00\00\00\00\00\00\00\00\00\00") + (data $129 (i32.const 6828) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00C\00\00\00\00\00\00\00\00\00\00\00") + (data $130 (i32.const 6860) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00D\00\00\00\00\00\00\00\00\00\00\00") + (data $131 (i32.const 6892) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00E\00\00\00\00\00\00\00\00\00\00\00") + (data $132 (i32.const 6924) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00F\00\00\00\00\00\00\00\00\00\00\00") + (data $133 (i32.const 6956) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00G\00\00\00\00\00\00\00\00\00\00\00") + (data $134 (i32.const 6988) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00H\00\00\00\00\00\00\00\00\00\00\00") + (data $135 (i32.const 7020) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00I\00\00\00\00\00\00\00\00\00\00\00") + (data $136 (i32.const 7052) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00J\00\00\00\00\00\00\00\00\00\00\00") + (data $137 (i32.const 7084) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00K\00\00\00\00\00\00\00\00\00\00\00") + (data $138 (i32.const 7116) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00L\00\00\00\00\00\00\00\00\00\00\00") + (data $139 (i32.const 7148) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00M\00\00\00\00\00\00\00\00\00\00\00") + (data $140 (i32.const 7180) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00N\00\00\00\00\00\00\00\00\00\00\00") + (data $141 (i32.const 7212) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00O\00\00\00\00\00\00\00\00\00\00\00") + (data $142 (i32.const 7244) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00P\00\00\00\00\00\00\00\00\00\00\00") + (data $143 (i32.const 7276) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00Q\00\00\00\00\00\00\00\00\00\00\00") + (data $144 (i32.const 7308) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00R\00\00\00\00\00\00\00\00\00\00\00") + (data $145 (i32.const 7340) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00S\00\00\00\00\00\00\00\00\00\00\00") + (data $146 (i32.const 7372) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00T\00\00\00\00\00\00\00\00\00\00\00") + (data $147 (i32.const 7404) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00U\00\00\00\00\00\00\00\00\00\00\00") + (data $148 (i32.const 7436) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00V\00\00\00\00\00\00\00\00\00\00\00") + (data $149 (i32.const 7468) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00W\00\00\00\00\00\00\00\00\00\00\00") + (data $150 (i32.const 7500) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00X\00\00\00\00\00\00\00\00\00\00\00") + (data $151 (i32.const 7532) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00Y\00\00\00\00\00\00\00\00\00\00\00") + (data $152 (i32.const 7564) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00m\00a\00x\00\00\00\00\00\00\00") + (data $153 (i32.const 7596) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00Z\00\00\00\00\00\00\00\00\00\00\00") + (data $154 (i32.const 7628) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00m\00a\00x\00_\00u\00\00\00") + (data $155 (i32.const 7660) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00[\00\00\00\00\00\00\00\00\00\00\00") + (data $156 (i32.const 7692) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00m\00i\00n\00\00\00\00\00\00\00") + (data $157 (i32.const 7724) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\\\00\00\00\00\00\00\00\00\00\00\00") + (data $158 (i32.const 7756) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00m\00i\00n\00_\00u\00\00\00") + (data $159 (i32.const 7788) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") + (data $160 (i32.const 7820) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00a\00d\00d\00_\003\002\00") + (data $161 (i32.const 7852) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00^\00\00\00\00\00\00\00\00\00\00\00") + (data $162 (i32.const 7884) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00_\00\00\00\00\00\00\00\00\00\00\00") + (data $163 (i32.const 7916) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00`\00\00\00\00\00\00\00\00\00\00\00") + (data $164 (i32.const 7948) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") + (data $165 (i32.const 7980) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") + (data $166 (i32.const 8012) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") + (data $167 (i32.const 8044) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") + (data $168 (i32.const 8076) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00e\00\00\00\00\00\00\00\00\00\00\00") + (data $169 (i32.const 8108) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00f\00\00\00\00\00\00\00\00\00\00\00") + (data $170 (i32.const 8140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00r\00o\00t\00_\00r\00_\006\004\00_\00i\00m\00m\00\00\00\00\00") + (data $171 (i32.const 8188) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00g\00\00\00\00\00\00\00\00\00\00\00") + (data $172 (i32.const 8220) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00r\00o\00t\00_\00r\00_\006\004\00_\00i\00m\00m\00_\00a\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $173 (i32.const 8284) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00h\00\00\00\00\00\00\00\00\00\00\00") + (data $174 (i32.const 8316) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00r\00o\00t\00_\00l\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $175 (i32.const 8364) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00i\00\00\00\00\00\00\00\00\00\00\00") + (data $176 (i32.const 8396) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00r\00o\00t\00_\00l\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $177 (i32.const 8444) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00j\00\00\00\00\00\00\00\00\00\00\00") + (data $178 (i32.const 8476) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00h\00\00\00S\00h\00o\00w\00 \00f\00a\00i\00l\00 \00w\00h\00e\00n\00 \00a\00c\00c\00e\00s\00s\00i\00n\00g\00 \00a\00n\00y\00 \00o\00f\00 \00t\00h\00e\00 \00i\00n\00i\00t\00i\00a\00l\00 \001\006\00 \00p\00a\00g\00e\00s\00\00\00\00\00") + (data $179 (i32.const 8604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t\00\00\00\00\00\00\00\00\00") + (data $180 (i32.const 8668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s\00\00\00\00\00\00\00") + (data $181 (i32.const 8716) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $182 (i32.const 8844) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $183 (i32.const 8924) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00a\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $184 (i32.const 8972) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $185 (i32.const 9020) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00t\00r\00u\00e\00\00\00\00\00") + (data $186 (i32.const 9052) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00f\00a\00l\00s\00e\00\00\00") + (data $187 (i32.const 9084) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $188 (i32.const 9132) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $189 (i32.const 9180) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00a\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $190 (i32.const 9228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00b\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $191 (i32.const 9276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00b\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $192 (i32.const 9324) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00k\00\00\00\00\00\00\00\00\00\00\00") + (data $193 (i32.const 9356) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00S\00h\00o\00w\00 \00f\00a\00i\00l\00 \00o\00n\00 \00m\00i\00s\00s\00i\00n\00g\00 \00p\00a\00g\00e\00 \00o\00r\00 \00i\00n\00v\00a\00l\00i\00d\00 \00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00") + (data $194 (i32.const 9468) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 \00") + (data $195 (i32.const 9564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y\00") + (data $196 (i32.const 9612) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.\00") + (data $197 (i32.const 9708) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00c\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $198 (i32.const 9756) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00c\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $199 (i32.const 9804) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00l\00\00\00\00\00\00\00\00\00\00\00") + (data $200 (i32.const 9836) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00s\00h\00o\00u\00l\00d\00 \00r\00e\00a\00d\00 \00a\00n\00d\00 \00w\00r\00i\00t\00e\00 \00a\00c\00r\00o\00s\00s\00 \00p\00a\00g\00e\00s\00\00\00\00\00\00\00\00\00") + (data $201 (i32.const 9932) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\10\00\00\00\de\00\00\00\ad\00\00\00\be\00\00\00\ef\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $202 (i32.const 9980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") + (data $203 (i32.const 10012) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00J\00\00\001\007\003\00,\001\009\000\00,\002\003\009\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00\00\00") + (data $204 (i32.const 10108) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") + (data $205 (i32.const 10156) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00N\00\00\002\002\002\00,\001\007\003\00,\001\009\000\00,\002\003\009\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $206 (i32.const 10268) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00m\00\00\00\00\00\00\00\00\00\00\00") + (data $207 (i32.const 10300) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00`\00\00\00s\00h\00o\00u\00l\00d\00 \00a\00l\00l\00o\00w\00 \000\00-\00b\00y\00t\00e\00s\00 \00r\00e\00a\00d\00s\00 \00a\00n\00d\00 \00w\00r\00i\00t\00e\00s\00 \00e\00v\00e\00r\00y\00w\00h\00e\00r\00e\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $208 (i32.const 10428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00d\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $209 (i32.const 10476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00e\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $210 (i32.const 10524) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00n\00\00\00\00\00\00\00\00\00\00\00") + (data $211 (i32.const 10556) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00o\00\00\00\00\00\00\00\00\00\00\00") + (data $212 (i32.const 10588) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00p\00\00\00\00\00\00\00\00\00\00\00") + (data $213 (i32.const 10620) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00q\00\00\00\00\00\00\00\00\00\00\00") + (data $214 (i32.const 10652) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00r\00\00\00\00\00\00\00\00\00\00\00") + (data $215 (i32.const 10684) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $216 (i32.const 10716) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00t\00\00\00\00\00\00\00\00\00\00\00") + (data $217 (i32.const 10748) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00u\00\00\00\00\00\00\00\00\00\00\00") + (data $218 (i32.const 10780) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00v\00\00\00\00\00\00\00\00\00\00\00") + (data $219 (i32.const 10812) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00w\00\00\00\00\00\00\00\00\00\00\00") + (data $220 (i32.const 10844) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00x\00\00\00\00\00\00\00\00\00\00\00") + (data $221 (i32.const 10876) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00y\00\00\00\00\00\00\00\00\00\00\00") + (data $222 (i32.const 10908) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00z\00\00\00\00\00\00\00\00\00\00\00") + (data $223 (i32.const 10940) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00{\00\00\00\00\00\00\00\00\00\00\00") + (data $224 (i32.const 10972) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00|\00\00\00\00\00\00\00\00\00\00\00") + (data $225 (i32.const 11004) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00}\00\00\00\00\00\00\00\00\00\00\00") + (data $226 (i32.const 11036) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00~\00\00\00\00\00\00\00\00\00\00\00") + (data $227 (i32.const 11068) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\7f\00\00\00\00\00\00\00\00\00\00\00") + (data $228 (i32.const 11100) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\80\00\00\00\00\00\00\00\00\00\00\00") + (data $229 (i32.const 11132) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\81\00\00\00\00\00\00\00\00\00\00\00") + (data $230 (i32.const 11164) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\82\00\00\00\00\00\00\00\00\00\00\00") + (data $231 (i32.const 11196) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\83\00\00\00\00\00\00\00\00\00\00\00") + (data $232 (i32.const 11228) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\84\00\00\00\00\00\00\00\00\00\00\00") + (data $233 (i32.const 11260) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\85\00\00\00\00\00\00\00\00\00\00\00") + (data $234 (i32.const 11292) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\86\00\00\00\00\00\00\00\00\00\00\00") + (data $235 (i32.const 11324) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\87\00\00\00\00\00\00\00\00\00\00\00") + (data $236 (i32.const 11356) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\88\00\00\00\00\00\00\00\00\00\00\00") + (data $237 (i32.const 11388) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\89\00\00\00\00\00\00\00\00\00\00\00") + (data $238 (i32.const 11420) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8a\00\00\00\00\00\00\00\00\00\00\00") + (data $239 (i32.const 11452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8b\00\00\00\00\00\00\00\00\00\00\00") + (data $240 (i32.const 11484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8c\00\00\00\00\00\00\00\00\00\00\00") + (data $241 (i32.const 11516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8d\00\00\00\00\00\00\00\00\00\00\00") + (data $242 (i32.const 11548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8e\00\00\00\00\00\00\00\00\00\00\00") + (data $243 (i32.const 11580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8f\00\00\00\00\00\00\00\00\00\00\00") + (data $244 (i32.const 11612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\90\00\00\00\00\00\00\00\00\00\00\00") + (data $245 (i32.const 11644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\91\00\00\00\00\00\00\00\00\00\00\00") + (data $246 (i32.const 11676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\92\00\00\00\00\00\00\00\00\00\00\00") + (data $247 (i32.const 11708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\93\00\00\00\00\00\00\00\00\00\00\00") + (data $248 (i32.const 11740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\94\00\00\00\00\00\00\00\00\00\00\00") + (data $249 (i32.const 11772) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\95\00\00\00\00\00\00\00\00\00\00\00") + (data $250 (i32.const 11804) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\96\00\00\00\00\00\00\00\00\00\00\00") + (data $251 (i32.const 11836) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\97\00\00\00\00\00\00\00\00\00\00\00") + (data $252 (i32.const 11868) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\98\00\00\00\00\00\00\00\00\00\00\00") + (data $253 (i32.const 11900) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\99\00\00\00\00\00\00\00\00\00\00\00") + (data $254 (i32.const 11932) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9a\00\00\00\00\00\00\00\00\00\00\00") + (data $255 (i32.const 11964) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9b\00\00\00\00\00\00\00\00\00\00\00") + (data $256 (i32.const 11996) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") + (data $257 (i32.const 12028) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") + (data $258 (i32.const 12060) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9e\00\00\00\00\00\00\00\00\00\00\00") + (data $259 (i32.const 12092) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9f\00\00\00\00\00\00\00\00\00\00\00") + (data $260 (i32.const 12124) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a0\00\00\00\00\00\00\00\00\00\00\00") + (data $261 (i32.const 12156) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a1\00\00\00\00\00\00\00\00\00\00\00") + (data $262 (i32.const 12188) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a2\00\00\00\00\00\00\00\00\00\00\00") + (data $263 (i32.const 12220) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a3\00\00\00\00\00\00\00\00\00\00\00") + (data $264 (i32.const 12252) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a4\00\00\00\00\00\00\00\00\00\00\00") + (data $265 (i32.const 12284) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a5\00\00\00\00\00\00\00\00\00\00\00") + (data $266 (i32.const 12316) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a6\00\00\00\00\00\00\00\00\00\00\00") + (data $267 (i32.const 12348) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a7\00\00\00\00\00\00\00\00\00\00\00") + (data $268 (i32.const 12380) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a8\00\00\00\00\00\00\00\00\00\00\00") + (data $269 (i32.const 12412) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a9\00\00\00\00\00\00\00\00\00\00\00") + (data $270 (i32.const 12444) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\aa\00\00\00\00\00\00\00\00\00\00\00") + (data $271 (i32.const 12476) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ab\00\00\00\00\00\00\00\00\00\00\00") + (data $272 (i32.const 12508) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ac\00\00\00\00\00\00\00\00\00\00\00") + (data $273 (i32.const 12540) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ad\00\00\00\00\00\00\00\00\00\00\00") + (data $274 (i32.const 12572) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ae\00\00\00\00\00\00\00\00\00\00\00") + (data $275 (i32.const 12604) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\af\00\00\00\00\00\00\00\00\00\00\00") + (data $276 (i32.const 12636) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b0\00\00\00\00\00\00\00\00\00\00\00") + (data $277 (i32.const 12668) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b1\00\00\00\00\00\00\00\00\00\00\00") + (data $278 (i32.const 12700) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b2\00\00\00\00\00\00\00\00\00\00\00") + (data $279 (i32.const 12732) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b3\00\00\00\00\00\00\00\00\00\00\00") + (data $280 (i32.const 12764) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b4\00\00\00\00\00\00\00\00\00\00\00") + (data $281 (i32.const 12796) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00\901\00\00\b01\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d01\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d0)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p/\00\00\90/\00\00\b0/\00\00\d0/\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00P)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p)\00\00\f0)\00\00\10*\00\000*\00\00P*\00\00p*\00\00\90*\00\00\b0*\00\00\d0*\00\00\f0/\00\00\100\00\0000\00\00P0\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p0\00\00\900\00\00\b00\00\00\d00\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\90)\00\00@\15\00\00`\15\00\00\80\15\00\00\a0\15\00\00\c0\15\00\00\e0\15\00\00\00\16\00\00 \16\00\00@\16\00\00`\16\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d0+\00\00\f01\00\00\c0\05\00\00\e0\05\00\00\00\06\00\00 \06\00\00@\06\00\00`\06\00\00\80\06\00\00\a0\06\00\00\c0\06\00\00\e0\06\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\f00\00\00\101\00\0001\00\00P1\00\00\f0*\00\00\10+\00\000+\00\00P+\00\00p+\00\00\90+\00\00\b0+\00\00@\1a\00\00P\18\00\00p\18\00\00\90\18\00\00`\1a\00\00p,\00\00\90,\00\000-\00\00P-\00\00p-\00\00\80\1a\00\00\b0,\00\00\d0,\00\00\90-\00\00\b0-\00\00\d0-\00\00\f0+\00\00\10,\00\00\a0\1a\00\00\c0\1a\00\00\f0-\00\00\10.\00\000.\00\00\e0\1a\00\00P.\00\00p.\00\00\90.\00\00\e0\1e\00\00\00\1f\00\00 \1f\00\00@\1f\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\80\16\00\00\a0\16\00\00\c0\16\00\00\e0\16\00\00\00\17\00\00 \17\00\00p1\00\00p1\00\00p1\00\00p1\00\00\b0)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\00\1b\00\00 \1b\00\00@\1b\00\00`\1b\00\00\80\1b\00\00\a0\1b\00\00\c0\1b\00\00\b0.\00\00\d0.\00\00\f0.\00\00\e0\1b\00\00\00\1c\00\00 \1c\00\00@\1c\00\00`\1c\00\00\80\1c\00\00\a0\1c\00\00\10/\00\000/\00\00P/\00\00\b0\18\00\00\d0\18\00\00\f0\18\00\00\c0\1c\00\00\e0\1c\00\00\00\1d\00\00\f0,\00\00\10-\00\000,\00\00P,\00\00`\1f\00\00\80\1f\00\00\a0\1f\00\00\c0\1f\00\00\10\19\00\000\19\00\00P\19\00\00 \1d\00\00@\1d\00\00`\1d\00\00\80\1d\00\00") + (data $282 (i32.const 13740) ",\00\00\00\00\00\00\00\00\00\00\00!\00\00\00\10\00\00\00\102\00\00\102\00\00\9c\03\00\00\e7\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $283 (i32.const 13788) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80\00\00\00\00") + (data $284 (i32.const 13820) ",\00\00\00\00\00\00\00\00\00\00\00\"\00\00\00\10\00\00\00\f05\00\00\f05\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $285 (i32.const 13868) "\1c\00\00\00\00\00\00\00\00\00\00\00#\00\00\00\08\00\00\00\b5\00\00\00\00\00\00\00\00\00\00\00") + (data $286 (i32.const 13900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $287 (i32.const 13948) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00S\00B\00R\00K\00\00\00\00\00") + (data $288 (i32.const 13980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00T\00R\00A\00P\00\00\00\00\00") + (data $289 (i32.const 14012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H\00\00\00\00\00\00\00") + (data $290 (i32.const 14060) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I\00") + (data $291 (i32.const 14092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00") + (data $292 (i32.const 14140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008\00\00\00\00\00") + (data $293 (i32.const 14188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006\00\00\00") + (data $294 (i32.const 14236) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002\00\00\00") + (data $295 (i32.const 14284) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004\00\00\00") + (data $296 (i32.const 14332) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00J\00U\00M\00P\00\00\00\00\00") + (data $297 (i32.const 14364) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $298 (i32.const 14412) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $299 (i32.const 14460) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $300 (i32.const 14508) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $301 (i32.const 14556) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $302 (i32.const 14604) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $303 (i32.const 14652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $304 (i32.const 14700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $305 (i32.const 14748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $306 (i32.const 14796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $307 (i32.const 14844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") + (data $308 (i32.const 14892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $309 (i32.const 14940) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $310 (i32.const 14988) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $311 (i32.const 15052) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") + (data $312 (i32.const 15116) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $313 (i32.const 15180) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $314 (i32.const 15244) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00\00\00") + (data $315 (i32.const 15292) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M\00\00\00") + (data $316 (i32.const 15340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M\00\00\00") + (data $317 (i32.const 15388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $318 (i32.const 15452) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $319 (i32.const 15516) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $320 (i32.const 15580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $321 (i32.const 15644) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $322 (i32.const 15708) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $323 (i32.const 15772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $324 (i32.const 15836) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $325 (i32.const 15900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $326 (i32.const 15948) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $327 (i32.const 16012) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $328 (i32.const 16076) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00") + (data $329 (i32.const 16140) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00") + (data $330 (i32.const 16204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00") + (data $331 (i32.const 16268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00") + (data $332 (i32.const 16332) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008\00\00\00") + (data $333 (i32.const 16380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") + (data $334 (i32.const 16428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") + (data $335 (i32.const 16476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S\00\00\00") + (data $336 (i32.const 16524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00") + (data $337 (i32.const 16572) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006\00\00\00") + (data $338 (i32.const 16620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002\00\00\00") + (data $339 (i32.const 16668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004\00\00\00") + (data $340 (i32.const 16716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00") + (data $341 (i32.const 16764) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008\00\00\00\00\00\00\00") + (data $342 (i32.const 16812) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00") + (data $343 (i32.const 16860) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006\00\00\00\00\00") + (data $344 (i32.const 16908) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00") + (data $345 (i32.const 16956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002\00\00\00\00\00") + (data $346 (i32.const 17004) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00") + (data $347 (i32.const 17052) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") + (data $348 (i32.const 17100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $349 (i32.const 17148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $350 (i32.const 17196) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M\00") + (data $351 (i32.const 17228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") + (data $352 (i32.const 17276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") + (data $353 (i32.const 17324) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") + (data $354 (i32.const 17372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $355 (i32.const 17420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $356 (i32.const 17468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") + (data $357 (i32.const 17516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00") + (data $358 (i32.const 17564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") + (data $359 (i32.const 17612) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") + (data $360 (i32.const 17660) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $361 (i32.const 17724) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $362 (i32.const 17788) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $363 (i32.const 17852) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") + (data $364 (i32.const 17900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") + (data $365 (i32.const 17948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") + (data $366 (i32.const 17996) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") + (data $367 (i32.const 18044) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $368 (i32.const 18092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $369 (i32.const 18140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") + (data $370 (i32.const 18188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00") + (data $371 (i32.const 18236) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $372 (i32.const 18300) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $373 (i32.const 18364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $374 (i32.const 18428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00\00\00\00\00") + (data $375 (i32.const 18476) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $376 (i32.const 18540) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00\00\00\00\00") + (data $377 (i32.const 18588) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $378 (i32.const 18652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00\00\00\00\00\00\00\00\00\00\00") + (data $379 (i32.const 18700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00\00\00\00\00\00\00\00\00\00\00") + (data $380 (i32.const 18748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00\00\00\00\00\00\00") + (data $381 (i32.const 18796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00\00\00\00\00\00\00") + (data $382 (i32.const 18844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00\00\00\00\00\00\00") + (data $383 (i32.const 18892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00\00\00\00\00\00\00") + (data $384 (i32.const 18940) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00") + (data $385 (i32.const 19004) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002\00") + (data $386 (i32.const 19036) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002\00") + (data $387 (i32.const 19068) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002\00") + (data $388 (i32.const 19100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $389 (i32.const 19148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $390 (i32.const 19196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $391 (i32.const 19244) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $392 (i32.const 19292) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $393 (i32.const 19340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $394 (i32.const 19388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") + (data $395 (i32.const 19436) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004\00") + (data $396 (i32.const 19468) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004\00") + (data $397 (i32.const 19500) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004\00") + (data $398 (i32.const 19532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $399 (i32.const 19580) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $400 (i32.const 19628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $401 (i32.const 19676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $402 (i32.const 19724) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $403 (i32.const 19772) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $404 (i32.const 19820) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") + (data $405 (i32.const 19868) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00A\00N\00D\00\00\00\00\00\00\00") + (data $406 (i32.const 19900) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00X\00O\00R\00\00\00\00\00\00\00") + (data $407 (i32.const 19932) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00O\00R\00\00\00\00\00\00\00\00\00") + (data $408 (i32.const 19964) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S\00\00\00") + (data $409 (i32.const 20012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U\00\00\00") + (data $410 (i32.const 20060) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U\00\00\00") + (data $411 (i32.const 20108) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $412 (i32.const 20156) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $413 (i32.const 20204) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $414 (i32.const 20252) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $415 (i32.const 20300) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $416 (i32.const 20348) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $417 (i32.const 20396) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $418 (i32.const 20444) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $419 (i32.const 20492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $420 (i32.const 20540) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V\00") + (data $421 (i32.const 20572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00X\00N\00O\00R\00\00\00\00\00") + (data $422 (i32.const 20604) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00A\00X\00\00\00\00\00\00\00") + (data $423 (i32.const 20636) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00A\00X\00_\00U\00\00\00") + (data $424 (i32.const 20668) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00I\00N\00\00\00\00\00\00\00") + (data $425 (i32.const 20700) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00I\00N\00_\00U\00\00\00") + (data $426 (i32.const 20732) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00s\00h\00o\00u\00l\00d\00 \00p\00a\00r\00s\00e\00 \00p\00a\00c\00k\00e\00d\00 \00m\00a\00s\00k\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00\00\00\00\00\00\00\00\00") + (data $427 (i32.const 20828) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\18\00\00\00\00\00\00\00\00\000@\00\00\00\00\00\00`@\00\00\00\00\00\00o@\00\00\00\00") + (data $428 (i32.const 20876) "l\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00T\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\n\00\00\00\t\00\00\00\08\00\00\00\07\00\00\00\06\00\00\00\05\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $429 (i32.const 20988) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00l\00e\00n\00g\00t\00h\00 \00@\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $430 (i32.const 21036) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b6\00\00\00\00\00\00\00\00\00\00\00") + (data $431 (i32.const 21068) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00X\00\00\00s\00h\00o\00u\00l\00d\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00 \00s\00k\00i\00p\00p\00i\00n\00g\00 \00m\00o\00r\00e\00 \00t\00h\00a\00n\00 \002\004\00 \00b\00y\00t\00e\00s\00\00\00\00\00") + (data $432 (i32.const 21180) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00`@\00\00\00\00\00\00\00\00\00\00\00\00") + (data $433 (i32.const 21244) "\9c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\80\00\00\00\00\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\18\00\00\00\17\00\00\00\16\00\00\00\15\00\00\00\14\00\00\00\13\00\00\00\12\00\00\00\11\00\00\00\10\00\00\00\0f\00\00\00\0e\00\00\00\r\00\00\00\0c\00\00\00\0b\00\00\00\n\00\00\00\t\00\00\00\08\00\00\00\07\00\00\00\06\00\00\00\05\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $434 (i32.const 21404) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b7\00\00\00\00\00\00\00\00\00\00\00") + (data $435 (i32.const 21436) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00B\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00\00\00\00\00\00\00\00\00\00\00") + (data $436 (i32.const 21532) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\00\00\00\00\00\00\00") + (data $437 (i32.const 21596) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $438 (i32.const 21724) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") + (data $439 (i32.const 21756) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") + (data $440 (i32.const 21788) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") + (data $441 (i32.const 21820) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") + (data $442 (i32.const 21852) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b8\00\00\00\00\00\00\00\00\00\00\00") + (data $443 (i32.const 21884) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00p\00o\00s\00i\00t\00i\00v\00e\00 \00b\00o\00u\00n\00d\00e\00d\00 \00b\00y\00 \00s\00k\00i\00p\00") + (data $444 (i32.const 21980) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\10\00\00\00\00\00\00\00\00\00\14@\00\00\00\00\00\00\14@\00\00\00\00\00\00\00\00\00\00\00\00") + (data $445 (i32.const 22028) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b9\00\00\00\00\00\00\00\00\00\00\00") + (data $446 (i32.const 22060) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00b\00l\00o\00b\00 \00p\00r\00o\00g\00r\00a\00m\00\00\00") + (data $447 (i32.const 22124) "\\\01\00\00\00\00\00\00\00\00\00\00\01\00\00\00H\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\80@@\00\00\00\00\00\80I@\00\00\00\00\00\00 @\00\00\00\00\00\00\f0?\00\00\00\00\00\80I@\00\00\00\00\00\00\"@\00\00\00\00\00\00\f0?\00\00\00\00\00\00D@\00\00\00\00\00\00\08@\00\00\00\00\00\00\00\00\00\00\00\00\00\a0b@\00\00\00\00\00\c0]@\00\00\00\00\00\e0o@\00\00\00\00\00@T@\00\00\00\00\00\00\1c@\00\00\00\00\00\00(@\00\00\00\00\00\00Y@\00\00\00\00\00@a@\00\00\00\00\00\00i@\00\00\00\00\00\00c@\00\00\00\00\00\00 @\00\00\00\00\00\00Y@\00\00\00\00\00 e@\00\00\00\00\00\00D@\00\00\00\00\00`n@\00\00\00\00\00\00Y@\00\00\00\00\00\e0`@\00\00\00\00\00\80I@\00\00\00\00\00\00 @\00\00\00\00\00\80I@\00\00\00\00\00\00\"@\00\00\00\00\00\00\f0?\00\00\00\00\00\00I@\00\00\00\00\00\00\00\00\00\00\00\00\00@R@\00\00\00\00\00`b@\00\00\00\00\00\80T@\00\00\00\00\00\a0j@\00\00\00\00\00\00\00\00\00\00\00\00") + (data $448 (i32.const 22476) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 \00\00\00") + (data $449 (i32.const 22556) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $450 (i32.const 22604) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\e0W\00\00\00\00\00\000X\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $451 (i32.const 22652) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $452 (i32.const 22716) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 \00\00\00\00\00\00\00\00\00") + (data $453 (i32.const 22828) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $454 (i32.const 22876) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\d0X\00\00\00\00\00\00@Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $455 (i32.const 22924) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00a\00s\00k\00[\00\00\00") + (data $456 (i32.const 22956) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00,\00 \00\00\00\00\00\00\00\00\00") + (data $457 (i32.const 22988) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") + (data $458 (i32.const 23020) "\ec\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\d2\00\00\00M\00a\00s\00k\00[\000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \000\00,\00 \001\00,\00 \00]\00\00\00\00\00\00\00\00\00\00\00") + (data $459 (i32.const 23260) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00\00\00\00\00\00\00\00\00") + (data $460 (i32.const 23308) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00-\00>\00 \00\00\00\00\00") + (data $461 (i32.const 23340) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00 [\00\00\00\00\00\00\c0Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $462 (i32.const 23388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00]\00\00\00\00\00\00\00") + (data $463 (i32.const 23436) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\00\00\00\00\00") + (data $464 (i32.const 23484) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00s\00t\00a\00r\00t\00\00\00") + (data $465 (i32.const 23516) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00e\00n\00d\00\00\00\00\00\00\00") + (data $466 (i32.const 23548) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00 [\00\00\00\00\00\00\c0Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $467 (i32.const 23596) ",\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\01\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \006\00 \00-\00>\00 \00e\00n\00d\00,\00 \008\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \009\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \001\002\00 \00-\00>\00 \00e\00n\00d\00,\00 \001\005\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \002\002\00 \00-\00>\00 \00e\00n\00d\00,\00 \002\004\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \003\000\00 \00-\00>\00 \00e\00n\00d\00,\00 \003\001\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \00]\00\00\00\00\00\00\00\00\00\00\00") + (data $468 (i32.const 23900) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\ba\00\00\00\00\00\00\00\00\00\00\00") + (data $469 (i32.const 23932) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00j\00\00\00s\00h\00o\00u\00l\00d\00 \00c\00o\00n\00s\00t\00r\00u\00c\00t\00 \00b\00a\00s\00i\00c\00 \00b\00l\00o\00c\00k\00s\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00 \00b\00a\00s\00e\00d\00 \00o\00n\00 \00s\00k\00i\00p\00\00\00") + (data $470 (i32.const 24060) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00Z\00\00\00O\00p\00c\00o\00d\00e\00 \00n\00o\00t\00 \00f\00o\00u\00n\00d\00 \00i\00n\00 \00R\00U\00N\00 \00t\00a\00b\00l\00e\00 \00f\00o\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00\00\00") + (data $471 (i32.const 24172) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00e\00s\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $472 (i32.const 24252) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00`@\00\00\00\00\00\00\00\00\00\00\00\00") + (data $473 (i32.const 24316) "\0c\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\f6\00\00\00M\00a\00s\00k\00[\000\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\004\00,\00 \002\003\00,\00 \002\002\00,\00 \002\001\00,\00 \002\000\00,\00 \001\009\00,\00 \001\008\00,\00 \001\007\00,\00 \001\006\00,\00 \001\005\00,\00 \001\004\00,\00 \001\003\00,\00 \001\002\00,\00 \001\001\00,\00 \001\000\00,\00 \009\00,\00 \008\00,\00 \007\00,\00 \006\00,\00 \005\00,\00 \004\00,\00 \003\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \00]\00\00\00\00\00\00\00") + (data $474 (i32.const 24588) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00h\00\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \002\006\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \003\001\00 \00-\00>\00 \00e\00n\00d\00,\00 \00]\00\00\00\00\00") + (data $475 (i32.const 24716) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bb\00\00\00\00\00\00\00\00\00\00\00") + (data $476 (i32.const 24748) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00s\00h\00o\00u\00l\00d\00 \00p\00a\00r\00s\00e\00 \00j\00u\00m\00p\00 \00t\00a\00b\00l\00e\00 \00w\00i\00t\00h\00 \00l\00a\00r\00g\00e\00 \00n\00u\00m\00b\00e\00r\00s\00\00\00\00\00\00\00\00\00") + (data $477 (i32.const 24860) "\0c\01\00\00\00\00\00\00\00\00\00\00\01\00\00\00\f0\00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $478 (i32.const 25132) "\cc\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\b8\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\000\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \001\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \002\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \00]\00\00\00\00\00") + (data $479 (i32.const 25340) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bc\00\00\00\00\00\00\00\00\00\00\00") + (data $480 (i32.const 25372) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00<\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00s\00t\00a\00n\00d\00a\00r\00d\00 \00p\00r\00o\00g\00r\00a\00m\00") + (data $481 (i32.const 25452) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\1c\00\00\00\04\00\00\02\00\00\03\00 \00\00\ab\cd\ef\01\124\07\00\00\00\00\00\03\c8\87\t\01") + (data $482 (i32.const 25500) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\03\00\00\00\124V\00\00\00\00\00\00\00\00\00") + (data $483 (i32.const 25532) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00A\00r\00g\00u\00m\00e\00n\00t\00s\00 \00l\00e\00n\00g\00t\00h\00 \00t\00o\00o\00 \00b\00i\00g\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $484 (i32.const 25612) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00s\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $485 (i32.const 25676) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") + (data $486 (i32.const 25804) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00\00\00\00\00\00\00") + (data $487 (i32.const 25884) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $488 (i32.const 25948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \00\00\00") + (data $489 (i32.const 25996) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00}\00\00\00\00\00\00\00\00\00") + (data $490 (i32.const 26028) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00\e0d\00\00\00\00\00\000e\00\00\00\00\00\00pe\00\00\00\00\00\00\a0e\00\00") + (data $491 (i32.const 26076) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $492 (i32.const 26140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00m\00a\00s\00k\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $493 (i32.const 26188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00\00\00") + (data $494 (i32.const 26236) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $495 (i32.const 26300) "<\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00$\00\00\00\f0e\00\00\00\00\00\000f\00\00\00\00\00\00`f\00\00\00\00\00\00\90f\00\00\00\00\00\00\a0e\00\00\00\00\00\00\00\00\00\00") + (data $496 (i32.const 26364) "\dc\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\c2\01\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \002\000\000\00,\001\003\005\00,\009\00,\00 \00m\00a\00s\00k\00:\00 \00M\00a\00s\00k\00[\000\00,\00 \002\00,\00 \001\00,\00 \00]\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00]\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \00]\00 \00}\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \007\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \004\002\009\004\009\000\001\007\006\000\00,\004\002\007\008\000\005\009\000\000\008\00,\000\00,\000\00,\000\00,\000\00,\000\00,\004\002\007\008\001\002\004\005\004\004\00,\003\00,\000\00,\000\00,\000\00,\000\00 \00}\00\00\00\00\00\00\00\00\00\00\00") + (data $497 (i32.const 26844) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bd\00\00\00\00\00\00\00\00\00\00\00") + (data $498 (i32.const 26876) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00b\00i\00t\00.\00t\00s\00") + (data $499 (i32.const 26908) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00>\00 \00\00\00\00\00\00\00\00\00") + (data $500 (i32.const 26940) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00>\00>\00>\00 \00") + (data $501 (i32.const 26972) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00<\00<\00<\00 \00") + (data $502 (i32.const 27004) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00\05\'\00\00\00\00\00\00\00\00") + (data $503 (i32.const 27036) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00pi\00\00\00\00\00\00\90i\00\00") + (data $504 (i32.const 27068) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00 \00 \00 \00\00\00\00\00") + (data $505 (i32.const 27100) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00=\d84\dd\00\00\00\00\00\00") + (data $506 (i32.const 27132) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00pi\00\00\00\00\00\00\f0i\00\00") + (data $507 (i32.const 27164) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00<\00 \00\00\00\00\00\00\00\00\00") + (data $508 (i32.const 27196) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\05\'\00\00\00\00\00\00\00\00\00\00") + (data $509 (i32.const 27228) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00=\d84\dd\00\00\00\00\00\00\00\00") + (data $510 (i32.const 27260) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $511 (i32.const 27292) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00/\00 \00\00\00\00\00\00\00") + (data $512 (i32.const 27324) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00\00\00\00\00\90j\00\00\00\00\00\00\b0j\00\00\00\00\00\00\90j\00\00\00\00\00\00") + (data $513 (i32.const 27372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00b\00r\00a\00n\00c\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $514 (i32.const 27420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00l\00o\00g\00i\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $515 (i32.const 27468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00m\00a\00t\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $516 (i32.const 27516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $517 (i32.const 27564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $518 (i32.const 27612) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00r\00o\00t\00.\00t\00s\00") + (data $519 (i32.const 27644) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00s\00p\00i\00.\00t\00s\00") + (data $520 (i32.const 27676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00\n\00\n\00T\00o\00t\00a\00l\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $521 (i32.const 27724) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00S\00o\00m\00e\00 \00t\00e\00s\00t\00s\00 \00f\00a\00i\00l\00e\00d\00.\00\00\00\00\00\00\00\00\00") + (data $522 (i32.const 27788) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00t\00e\00s\00t\00-\00r\00u\00n\00.\00t\00s\00\00\00\00\00") + (data $523 (i32.const 27856) "0\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\02A\00\00\02A\00\00\00\00\00\00\04A\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00A\00\00\00\02A\00\00B\00\00\00\00\00\00\00\02\01\00\00\00\00\00\00$\01\00\00\02\1a\00\00\02\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\t\00\00\00\00\00\00 \00\00\00\00\00\00\00") + (table $0 190 190 funcref) + (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/bit.test~anonymous|0 $start:assembly/instructions/bit.test~anonymous|1 $start:assembly/instructions/bit.test~anonymous|2 $start:assembly/instructions/bit.test~anonymous|3 $start:assembly/instructions/bit.test~anonymous|4 $start:assembly/instructions/bit.test~anonymous|5 $start:assembly/instructions/bit.test~anonymous|6 $start:assembly/instructions/bit.test~anonymous|7 $start:assembly/instructions/bit.test~anonymous|8 $start:assembly/instructions/bit.test~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/branch.test~anonymous|0 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/logic.test~anonymous|0 $start:assembly/instructions/logic.test~anonymous|1 $start:assembly/instructions/logic.test~anonymous|2 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/math.test~anonymous|0 $start:assembly/instructions/math.test~anonymous|1 $start:assembly/instructions/math.test~anonymous|2 $start:assembly/instructions/math.test~anonymous|3 $start:assembly/instructions/math.test~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/rot.test~anonymous|0 $start:assembly/instructions/rot.test~anonymous|1 $start:assembly/instructions/rot.test~anonymous|2 $start:assembly/instructions/rot.test~anonymous|3 $start:assembly/memory.test~anonymous|0 $start:assembly/memory.test~anonymous|1 $start:assembly/memory.test~anonymous|2 $start:assembly/memory.test~anonymous|3 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $start:assembly/program.test~anonymous|0 $start:assembly/program.test~anonymous|1 $start:assembly/program.test~anonymous|2 $start:assembly/program.test~anonymous|3 $start:assembly/program.test~anonymous|4 $start:assembly/program.test~anonymous|5 $start:assembly/program.test~anonymous|6 $start:assembly/spi.test~anonymous|0) + (export "runAllTests" (func $assembly/test-run/runAllTests)) + (export "memory" (memory $0)) + (start $~start) + (func $~lib/rt/itcms/Object#set:nextWithColor (param $this i32) (param $nextWithColor i32) + local.get $this + local.get $nextWithColor + i32.store offset=4 + ) + (func $~lib/rt/itcms/Object#set:prev (param $this i32) (param $prev i32) + local.get $this + local.get $prev + i32.store offset=8 + ) + (func $~lib/rt/itcms/initLazy (param $space i32) (result i32) + local.get $space + local.get $space + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $space + local.get $space + call $~lib/rt/itcms/Object#set:prev + local.get $space + return + ) + (func $~lib/rt/itcms/Object#get:nextWithColor (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/rt/itcms/Object#get:next (param $this i32) (result i32) + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.const -1 + i32.xor + i32.and + return + ) + (func $~lib/rt/itcms/Object#get:color (param $this i32) (result i32) + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.and + return + ) + (func $~lib/rt/itcms/visitRoots (param $cookie i32) + (local $pn i32) + (local $iter i32) + local.get $cookie + call $~lib/rt/__visit_globals + global.get $~lib/rt/itcms/pinSpace + local.set $pn + local.get $pn + call $~lib/rt/itcms/Object#get:next + local.set $iter + loop $while-continue|0 + local.get $iter + local.get $pn + i32.ne + if + i32.const 1 + drop + local.get $iter + call $~lib/rt/itcms/Object#get:color + i32.const 3 + i32.eq + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 160 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $iter + i32.const 20 + i32.add + local.get $cookie + call $~lib/rt/__visit_members + local.get $iter + call $~lib/rt/itcms/Object#get:next + local.set $iter + br $while-continue|0 + end + end + ) + (func $~lib/rt/itcms/Object#set:color (param $this i32) (param $color i32) + local.get $this + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $color + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + ) + (func $~lib/rt/itcms/Object#get:prev (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/rt/itcms/Object#set:next (param $this i32) (param $obj i32) + local.get $this + local.get $obj + local.get $this + call $~lib/rt/itcms/Object#get:nextWithColor + i32.const 3 + i32.and + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + ) + (func $~lib/rt/itcms/Object#unlink (param $this i32) + (local $next i32) + (local $prev i32) + local.get $this + call $~lib/rt/itcms/Object#get:next + local.set $next + local.get $next + i32.const 0 + i32.eq + if + i32.const 1 + drop + local.get $this + call $~lib/rt/itcms/Object#get:prev + i32.const 0 + i32.eq + if (result i32) + local.get $this + global.get $~lib/memory/__heap_base + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 128 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + return + end + local.get $this + call $~lib/rt/itcms/Object#get:prev + local.set $prev + i32.const 1 + drop + local.get $prev + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 132 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $next + local.get $prev + call $~lib/rt/itcms/Object#set:prev + local.get $prev + local.get $next + call $~lib/rt/itcms/Object#set:next + ) + (func $~lib/rt/itcms/Object#get:rtId (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/shared/typeinfo/Typeinfo#get:flags (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/__typeinfo (param $id i32) (result i32) + (local $ptr i32) + global.get $~lib/rt/__rtti_base + local.set $ptr + local.get $id + local.get $ptr + i32.load + i32.gt_u + if + i32.const 480 + i32.const 544 + i32.const 21 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $ptr + i32.const 4 + i32.add + local.get $id + i32.const 4 + i32.mul + i32.add + call $~lib/shared/typeinfo/Typeinfo#get:flags + return + ) + (func $~lib/rt/itcms/Object#get:isPointerfree (param $this i32) (result i32) + (local $rtId i32) + local.get $this + call $~lib/rt/itcms/Object#get:rtId + local.set $rtId + local.get $rtId + i32.const 2 + i32.le_u + if (result i32) + i32.const 1 + else + local.get $rtId + call $~lib/rt/__typeinfo + i32.const 32 + i32.and + i32.const 0 + i32.ne + end + return + ) + (func $~lib/rt/itcms/Object#linkTo (param $this i32) (param $list i32) (param $withColor i32) + (local $prev i32) + local.get $list + call $~lib/rt/itcms/Object#get:prev + local.set $prev + local.get $this + local.get $list + local.get $withColor + i32.or + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $this + local.get $prev + call $~lib/rt/itcms/Object#set:prev + local.get $prev + local.get $this + call $~lib/rt/itcms/Object#set:next + local.get $list + local.get $this + call $~lib/rt/itcms/Object#set:prev + ) + (func $~lib/rt/itcms/Object#makeGray (param $this i32) + (local $1 i32) + local.get $this + global.get $~lib/rt/itcms/iter + i32.eq + if + local.get $this + call $~lib/rt/itcms/Object#get:prev + local.tee $1 + i32.eqz + if (result i32) + i32.const 0 + i32.const 352 + i32.const 148 + i32.const 30 + call $~lib/builtins/abort + unreachable + else + local.get $1 + end + global.set $~lib/rt/itcms/iter + end + local.get $this + call $~lib/rt/itcms/Object#unlink + local.get $this + global.get $~lib/rt/itcms/toSpace + local.get $this + call $~lib/rt/itcms/Object#get:isPointerfree + if (result i32) + global.get $~lib/rt/itcms/white + i32.eqz + else + i32.const 2 + end + call $~lib/rt/itcms/Object#linkTo + ) + (func $~lib/rt/itcms/__visit (param $ptr i32) (param $cookie i32) + (local $obj i32) + local.get $ptr + i32.eqz + if + return + end + local.get $ptr + i32.const 20 + i32.sub + local.set $obj + i32.const 0 + drop + local.get $obj + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eq + if + local.get $obj + call $~lib/rt/itcms/Object#makeGray + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.add + global.set $~lib/rt/itcms/visitCount + end + ) + (func $~lib/rt/itcms/visitStack (param $cookie i32) + (local $ptr i32) + global.get $~lib/memory/__stack_pointer + local.set $ptr + loop $while-continue|0 + local.get $ptr + global.get $~lib/memory/__heap_base + i32.lt_u + if + local.get $ptr + i32.load + local.get $cookie + call $~lib/rt/itcms/__visit + local.get $ptr + i32.const 4 + i32.add + local.set $ptr + br $while-continue|0 + end + end + ) + (func $~lib/rt/common/BLOCK#get:mmInfo (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/itcms/Object#get:size (param $this i32) (result i32) + i32.const 4 + local.get $this + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + return + ) + (func $~lib/rt/tlsf/Root#set:flMap (param $this i32) (param $flMap i32) + local.get $this + local.get $flMap + i32.store + ) + (func $~lib/rt/common/BLOCK#set:mmInfo (param $this i32) (param $mmInfo i32) + local.get $this + local.get $mmInfo + i32.store + ) + (func $~lib/rt/tlsf/Block#set:prev (param $this i32) (param $prev i32) + local.get $this + local.get $prev + i32.store offset=4 + ) + (func $~lib/rt/tlsf/Block#set:next (param $this i32) (param $next i32) + local.get $this + local.get $next + i32.store offset=8 + ) + (func $~lib/rt/tlsf/Block#get:prev (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/rt/tlsf/Block#get:next (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/rt/tlsf/Root#get:flMap (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/tlsf/removeBlock (param $root i32) (param $block i32) + (local $blockInfo i32) + (local $size i32) + (local $fl i32) + (local $sl i32) + (local $6 i32) + (local $7 i32) + (local $boundedSize i32) + (local $prev i32) + (local $next i32) + (local $root|11 i32) + (local $fl|12 i32) + (local $sl|13 i32) + (local $root|14 i32) + (local $fl|15 i32) + (local $sl|16 i32) + (local $head i32) + (local $root|18 i32) + (local $fl|19 i32) + (local $slMap i32) + (local $root|21 i32) + (local $fl|22 i32) + (local $slMap|23 i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $blockInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 268 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.set $size + i32.const 1 + drop + local.get $size + i32.const 12 + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 270 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + local.tee $6 + i32.const 1073741820 + local.tee $7 + local.get $6 + local.get $7 + i32.lt_u + select + local.set $boundedSize + i32.const 31 + local.get $boundedSize + i32.clz + i32.sub + local.set $fl + local.get $boundedSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 284 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $block + call $~lib/rt/tlsf/Block#get:prev + local.set $prev + local.get $block + call $~lib/rt/tlsf/Block#get:next + local.set $next + local.get $prev + if + local.get $prev + local.get $next + call $~lib/rt/tlsf/Block#set:next + end + local.get $next + if + local.get $next + local.get $prev + call $~lib/rt/tlsf/Block#set:prev + end + local.get $block + block $~lib/rt/tlsf/GETHEAD|inlined.0 (result i32) + local.get $root + local.set $root|11 + local.get $fl + local.set $fl|12 + local.get $sl + local.set $sl|13 + local.get $root|11 + local.get $fl|12 + i32.const 4 + i32.shl + local.get $sl|13 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.0 + end + i32.eq + if + local.get $root + local.set $root|14 + local.get $fl + local.set $fl|15 + local.get $sl + local.set $sl|16 + local.get $next + local.set $head + local.get $root|14 + local.get $fl|15 + i32.const 4 + i32.shl + local.get $sl|16 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head + i32.store offset=96 + local.get $next + i32.eqz + if + block $~lib/rt/tlsf/GETSL|inlined.0 (result i32) + local.get $root + local.set $root|18 + local.get $fl + local.set $fl|19 + local.get $root|18 + local.get $fl|19 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.0 + end + local.set $slMap + local.get $root + local.set $root|21 + local.get $fl + local.set $fl|22 + local.get $slMap + i32.const 1 + local.get $sl + i32.shl + i32.const -1 + i32.xor + i32.and + local.tee $slMap + local.set $slMap|23 + local.get $root|21 + local.get $fl|22 + i32.const 2 + i32.shl + i32.add + local.get $slMap|23 + i32.store offset=4 + local.get $slMap + i32.eqz + if + local.get $root + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 1 + local.get $fl + i32.shl + i32.const -1 + i32.xor + i32.and + call $~lib/rt/tlsf/Root#set:flMap + end + end + end + ) + (func $~lib/rt/tlsf/insertBlock (param $root i32) (param $block i32) + (local $blockInfo i32) + (local $block|3 i32) + (local $right i32) + (local $rightInfo i32) + (local $block|6 i32) + (local $block|7 i32) + (local $left i32) + (local $leftInfo i32) + (local $size i32) + (local $fl i32) + (local $sl i32) + (local $13 i32) + (local $14 i32) + (local $boundedSize i32) + (local $root|16 i32) + (local $fl|17 i32) + (local $sl|18 i32) + (local $head i32) + (local $root|20 i32) + (local $fl|21 i32) + (local $sl|22 i32) + (local $head|23 i32) + (local $root|24 i32) + (local $fl|25 i32) + (local $root|26 i32) + (local $fl|27 i32) + (local $slMap i32) + i32.const 1 + drop + local.get $block + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 201 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $blockInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 203 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETRIGHT|inlined.0 (result i32) + local.get $block + local.set $block|3 + local.get $block|3 + i32.const 4 + i32.add + local.get $block|3 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.0 + end + local.set $right + local.get $right + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $rightInfo + local.get $rightInfo + i32.const 1 + i32.and + if + local.get $root + local.get $right + call $~lib/rt/tlsf/removeBlock + local.get $block + local.get $blockInfo + i32.const 4 + i32.add + local.get $rightInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + local.tee $blockInfo + call $~lib/rt/common/BLOCK#set:mmInfo + block $~lib/rt/tlsf/GETRIGHT|inlined.1 (result i32) + local.get $block + local.set $block|6 + local.get $block|6 + i32.const 4 + i32.add + local.get $block|6 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.1 + end + local.set $right + local.get $right + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $rightInfo + end + local.get $blockInfo + i32.const 2 + i32.and + if + block $~lib/rt/tlsf/GETFREELEFT|inlined.0 (result i32) + local.get $block + local.set $block|7 + local.get $block|7 + i32.const 4 + i32.sub + i32.load + br $~lib/rt/tlsf/GETFREELEFT|inlined.0 + end + local.set $left + local.get $left + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $leftInfo + i32.const 1 + drop + local.get $leftInfo + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 221 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $root + local.get $left + call $~lib/rt/tlsf/removeBlock + local.get $left + local.set $block + local.get $block + local.get $leftInfo + i32.const 4 + i32.add + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + local.tee $blockInfo + call $~lib/rt/common/BLOCK#set:mmInfo + end + local.get $right + local.get $rightInfo + i32.const 2 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.set $size + i32.const 1 + drop + local.get $size + i32.const 12 + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 233 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + i32.const 1 + drop + local.get $block + i32.const 4 + i32.add + local.get $size + i32.add + local.get $right + i32.eq + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 234 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $right + i32.const 4 + i32.sub + local.get $block + i32.store + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + local.tee $13 + i32.const 1073741820 + local.tee $14 + local.get $13 + local.get $14 + i32.lt_u + select + local.set $boundedSize + i32.const 31 + local.get $boundedSize + i32.clz + i32.sub + local.set $fl + local.get $boundedSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 251 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETHEAD|inlined.1 (result i32) + local.get $root + local.set $root|16 + local.get $fl + local.set $fl|17 + local.get $sl + local.set $sl|18 + local.get $root|16 + local.get $fl|17 + i32.const 4 + i32.shl + local.get $sl|18 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.1 + end + local.set $head + local.get $block + i32.const 0 + call $~lib/rt/tlsf/Block#set:prev + local.get $block + local.get $head + call $~lib/rt/tlsf/Block#set:next + local.get $head + if + local.get $head + local.get $block + call $~lib/rt/tlsf/Block#set:prev + end + local.get $root + local.set $root|20 + local.get $fl + local.set $fl|21 + local.get $sl + local.set $sl|22 + local.get $block + local.set $head|23 + local.get $root|20 + local.get $fl|21 + i32.const 4 + i32.shl + local.get $sl|22 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head|23 + i32.store offset=96 + local.get $root + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 1 + local.get $fl + i32.shl + i32.or + call $~lib/rt/tlsf/Root#set:flMap + local.get $root + local.set $root|26 + local.get $fl + local.set $fl|27 + block $~lib/rt/tlsf/GETSL|inlined.1 (result i32) + local.get $root + local.set $root|24 + local.get $fl + local.set $fl|25 + local.get $root|24 + local.get $fl|25 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.1 + end + i32.const 1 + local.get $sl + i32.shl + i32.or + local.set $slMap + local.get $root|26 + local.get $fl|27 + i32.const 2 + i32.shl + i32.add + local.get $slMap + i32.store offset=4 + ) + (func $~lib/rt/tlsf/addMemory (param $root i32) (param $start i32) (param $endU64 i64) (result i32) + (local $end i32) + (local $root|4 i32) + (local $tail i32) + (local $tailInfo i32) + (local $size i32) + (local $leftSize i32) + (local $left i32) + (local $root|10 i32) + (local $tail|11 i32) + local.get $endU64 + i32.wrap_i64 + local.set $end + i32.const 1 + drop + local.get $start + i64.extend_i32_u + local.get $endU64 + i64.le_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 382 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $start + i32.const 4 + i32.add + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + i32.const 4 + i32.sub + local.set $start + local.get $end + i32.const 15 + i32.const -1 + i32.xor + i32.and + local.set $end + block $~lib/rt/tlsf/GETTAIL|inlined.0 (result i32) + local.get $root + local.set $root|4 + local.get $root|4 + i32.load offset=1568 + br $~lib/rt/tlsf/GETTAIL|inlined.0 + end + local.set $tail + i32.const 0 + local.set $tailInfo + local.get $tail + if + i32.const 1 + drop + local.get $start + local.get $tail + i32.const 4 + i32.add + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 389 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + local.get $start + i32.const 16 + i32.sub + local.get $tail + i32.eq + if + local.get $start + i32.const 16 + i32.sub + local.set $start + local.get $tail + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $tailInfo + else + end + else + i32.const 1 + drop + local.get $start + local.get $root + i32.const 1572 + i32.add + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 402 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + end + local.get $end + local.get $start + i32.sub + local.set $size + local.get $size + i32.const 4 + i32.const 12 + i32.add + i32.const 4 + i32.add + i32.lt_u + if + i32.const 0 + return + end + local.get $size + i32.const 2 + i32.const 4 + i32.mul + i32.sub + local.set $leftSize + local.get $start + local.set $left + local.get $left + local.get $leftSize + i32.const 1 + i32.or + local.get $tailInfo + i32.const 2 + i32.and + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $left + i32.const 0 + call $~lib/rt/tlsf/Block#set:prev + local.get $left + i32.const 0 + call $~lib/rt/tlsf/Block#set:next + local.get $start + i32.const 4 + i32.add + local.get $leftSize + i32.add + local.set $tail + local.get $tail + i32.const 0 + i32.const 2 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.set $root|10 + local.get $tail + local.set $tail|11 + local.get $root|10 + local.get $tail|11 + i32.store offset=1568 + local.get $root + local.get $left + call $~lib/rt/tlsf/insertBlock + i32.const 1 + return + ) + (func $~lib/rt/tlsf/initialize + (local $rootOffset i32) + (local $pagesBefore i32) + (local $pagesNeeded i32) + (local $root i32) + (local $root|4 i32) + (local $tail i32) + (local $fl i32) + (local $root|7 i32) + (local $fl|8 i32) + (local $slMap i32) + (local $sl i32) + (local $root|11 i32) + (local $fl|12 i32) + (local $sl|13 i32) + (local $head i32) + (local $memStart i32) + i32.const 0 + drop + global.get $~lib/memory/__heap_base + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + local.set $rootOffset + memory.size + local.set $pagesBefore + local.get $rootOffset + i32.const 1572 + i32.add + i32.const 65535 + i32.add + i32.const 65535 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.shr_u + local.set $pagesNeeded + local.get $pagesNeeded + local.get $pagesBefore + i32.gt_s + if (result i32) + local.get $pagesNeeded + local.get $pagesBefore + i32.sub + memory.grow + i32.const 0 + i32.lt_s + else + i32.const 0 + end + if + unreachable + end + local.get $rootOffset + local.set $root + local.get $root + i32.const 0 + call $~lib/rt/tlsf/Root#set:flMap + local.get $root + local.set $root|4 + i32.const 0 + local.set $tail + local.get $root|4 + local.get $tail + i32.store offset=1568 + i32.const 0 + local.set $fl + loop $for-loop|0 + local.get $fl + i32.const 23 + i32.lt_u + if + local.get $root + local.set $root|7 + local.get $fl + local.set $fl|8 + i32.const 0 + local.set $slMap + local.get $root|7 + local.get $fl|8 + i32.const 2 + i32.shl + i32.add + local.get $slMap + i32.store offset=4 + i32.const 0 + local.set $sl + loop $for-loop|1 + local.get $sl + i32.const 16 + i32.lt_u + if + local.get $root + local.set $root|11 + local.get $fl + local.set $fl|12 + local.get $sl + local.set $sl|13 + i32.const 0 + local.set $head + local.get $root|11 + local.get $fl|12 + i32.const 4 + i32.shl + local.get $sl|13 + i32.add + i32.const 2 + i32.shl + i32.add + local.get $head + i32.store offset=96 + local.get $sl + i32.const 1 + i32.add + local.set $sl + br $for-loop|1 + end + end + local.get $fl + i32.const 1 + i32.add + local.set $fl + br $for-loop|0 + end + end + local.get $rootOffset + i32.const 1572 + i32.add + local.set $memStart + i32.const 0 + drop + local.get $root + local.get $memStart + memory.size + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + drop + local.get $root + global.set $~lib/rt/tlsf/ROOT + ) + (func $~lib/rt/tlsf/checkUsedBlock (param $ptr i32) (result i32) + (local $block i32) + local.get $ptr + i32.const 4 + i32.sub + local.set $block + local.get $ptr + i32.const 0 + i32.ne + if (result i32) + local.get $ptr + i32.const 15 + i32.and + i32.eqz + else + i32.const 0 + end + if (result i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 1 + i32.and + i32.eqz + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 562 + i32.const 3 + call $~lib/builtins/abort + unreachable + end + local.get $block + return + ) + (func $~lib/rt/tlsf/freeBlock (param $root i32) (param $block i32) + i32.const 0 + drop + local.get $block + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 1 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.get $block + call $~lib/rt/tlsf/insertBlock + ) + (func $~lib/rt/tlsf/__free (param $ptr i32) + local.get $ptr + global.get $~lib/memory/__heap_base + i32.lt_u + if + return + end + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $ptr + call $~lib/rt/tlsf/checkUsedBlock + call $~lib/rt/tlsf/freeBlock + ) + (func $~lib/rt/itcms/free (param $obj i32) + local.get $obj + global.get $~lib/memory/__heap_base + i32.lt_u + if + local.get $obj + i32.const 0 + call $~lib/rt/itcms/Object#set:nextWithColor + local.get $obj + i32.const 0 + call $~lib/rt/itcms/Object#set:prev + else + global.get $~lib/rt/itcms/total + local.get $obj + call $~lib/rt/itcms/Object#get:size + i32.sub + global.set $~lib/rt/itcms/total + i32.const 0 + drop + local.get $obj + i32.const 4 + i32.add + call $~lib/rt/tlsf/__free + end + ) + (func $~lib/rt/itcms/step (result i32) + (local $obj i32) + (local $1 i32) + (local $black i32) + (local $from i32) + block $break|0 + block $case2|0 + block $case1|0 + block $case0|0 + global.get $~lib/rt/itcms/state + local.set $1 + local.get $1 + i32.const 0 + i32.eq + br_if $case0|0 + local.get $1 + i32.const 1 + i32.eq + br_if $case1|0 + local.get $1 + i32.const 2 + i32.eq + br_if $case2|0 + br $break|0 + end + i32.const 1 + global.set $~lib/rt/itcms/state + i32.const 0 + global.set $~lib/rt/itcms/visitCount + i32.const 0 + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/iter + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + global.get $~lib/rt/itcms/white + i32.eqz + local.set $black + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + loop $while-continue|1 + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + global.set $~lib/rt/itcms/iter + local.get $obj + call $~lib/rt/itcms/Object#get:color + local.get $black + i32.ne + if + local.get $obj + local.get $black + call $~lib/rt/itcms/Object#set:color + i32.const 0 + global.set $~lib/rt/itcms/visitCount + local.get $obj + i32.const 20 + i32.add + i32.const 0 + call $~lib/rt/__visit_members + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + local.get $obj + call $~lib/rt/itcms/Object#get:next + local.set $obj + br $while-continue|1 + end + end + i32.const 0 + global.set $~lib/rt/itcms/visitCount + i32.const 0 + call $~lib/rt/itcms/visitRoots + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.eq + if + i32.const 0 + call $~lib/rt/itcms/visitStack + global.get $~lib/rt/itcms/iter + call $~lib/rt/itcms/Object#get:next + local.set $obj + loop $while-continue|2 + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + call $~lib/rt/itcms/Object#get:color + local.get $black + i32.ne + if + local.get $obj + local.get $black + call $~lib/rt/itcms/Object#set:color + local.get $obj + i32.const 20 + i32.add + i32.const 0 + call $~lib/rt/__visit_members + end + local.get $obj + call $~lib/rt/itcms/Object#get:next + local.set $obj + br $while-continue|2 + end + end + global.get $~lib/rt/itcms/fromSpace + local.set $from + global.get $~lib/rt/itcms/toSpace + global.set $~lib/rt/itcms/fromSpace + local.get $from + global.set $~lib/rt/itcms/toSpace + local.get $black + global.set $~lib/rt/itcms/white + local.get $from + call $~lib/rt/itcms/Object#get:next + global.set $~lib/rt/itcms/iter + i32.const 2 + global.set $~lib/rt/itcms/state + end + global.get $~lib/rt/itcms/visitCount + i32.const 1 + i32.mul + return + end + global.get $~lib/rt/itcms/iter + local.set $obj + local.get $obj + global.get $~lib/rt/itcms/toSpace + i32.ne + if + local.get $obj + call $~lib/rt/itcms/Object#get:next + global.set $~lib/rt/itcms/iter + i32.const 1 + drop + local.get $obj + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eqz + i32.eq + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 229 + i32.const 20 + call $~lib/builtins/abort + unreachable + end + local.get $obj + call $~lib/rt/itcms/free + i32.const 10 + return + end + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + call $~lib/rt/itcms/Object#set:nextWithColor + global.get $~lib/rt/itcms/toSpace + global.get $~lib/rt/itcms/toSpace + call $~lib/rt/itcms/Object#set:prev + i32.const 0 + global.set $~lib/rt/itcms/state + br $break|0 + end + i32.const 0 + return + ) + (func $~lib/rt/itcms/interrupt + (local $budget i32) + i32.const 0 + drop + i32.const 0 + drop + i32.const 1024 + i32.const 200 + i32.mul + i32.const 100 + i32.div_u + local.set $budget + loop $do-loop|0 + local.get $budget + call $~lib/rt/itcms/step + i32.sub + local.set $budget + global.get $~lib/rt/itcms/state + i32.const 0 + i32.eq + if + i32.const 0 + drop + global.get $~lib/rt/itcms/total + i64.extend_i32_u + i32.const 200 + i64.extend_i32_u + i64.mul + i64.const 100 + i64.div_u + i32.wrap_i64 + i32.const 1024 + i32.add + global.set $~lib/rt/itcms/threshold + i32.const 0 + drop + return + end + local.get $budget + i32.const 0 + i32.gt_s + br_if $do-loop|0 + end + i32.const 0 + drop + global.get $~lib/rt/itcms/total + i32.const 1024 + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.sub + i32.const 1024 + i32.lt_u + i32.mul + i32.add + global.set $~lib/rt/itcms/threshold + i32.const 0 + drop + ) + (func $~lib/rt/tlsf/computeSize (param $size i32) (result i32) + local.get $size + i32.const 12 + i32.le_u + if (result i32) + i32.const 12 + else + local.get $size + i32.const 4 + i32.add + i32.const 15 + i32.add + i32.const 15 + i32.const -1 + i32.xor + i32.and + i32.const 4 + i32.sub + end + return + ) + (func $~lib/rt/tlsf/prepareSize (param $size i32) (result i32) + local.get $size + i32.const 1073741820 + i32.gt_u + if + i32.const 288 + i32.const 624 + i32.const 461 + i32.const 29 + call $~lib/builtins/abort + unreachable + end + local.get $size + call $~lib/rt/tlsf/computeSize + return + ) + (func $~lib/rt/tlsf/roundSize (param $size i32) (result i32) + local.get $size + i32.const 536870910 + i32.lt_u + if (result i32) + local.get $size + i32.const 1 + i32.const 27 + local.get $size + i32.clz + i32.sub + i32.shl + i32.add + i32.const 1 + i32.sub + else + local.get $size + end + return + ) + (func $~lib/rt/tlsf/searchBlock (param $root i32) (param $size i32) (result i32) + (local $fl i32) + (local $sl i32) + (local $requestSize i32) + (local $root|5 i32) + (local $fl|6 i32) + (local $slMap i32) + (local $head i32) + (local $flMap i32) + (local $root|10 i32) + (local $fl|11 i32) + (local $root|12 i32) + (local $fl|13 i32) + (local $sl|14 i32) + (local $root|15 i32) + (local $fl|16 i32) + (local $sl|17 i32) + local.get $size + i32.const 256 + i32.lt_u + if + i32.const 0 + local.set $fl + local.get $size + i32.const 4 + i32.shr_u + local.set $sl + else + local.get $size + call $~lib/rt/tlsf/roundSize + local.set $requestSize + i32.const 4 + i32.const 8 + i32.mul + i32.const 1 + i32.sub + local.get $requestSize + i32.clz + i32.sub + local.set $fl + local.get $requestSize + local.get $fl + i32.const 4 + i32.sub + i32.shr_u + i32.const 1 + i32.const 4 + i32.shl + i32.xor + local.set $sl + local.get $fl + i32.const 8 + i32.const 1 + i32.sub + i32.sub + local.set $fl + end + i32.const 1 + drop + local.get $fl + i32.const 23 + i32.lt_u + if (result i32) + local.get $sl + i32.const 16 + i32.lt_u + else + i32.const 0 + end + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 334 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETSL|inlined.2 (result i32) + local.get $root + local.set $root|5 + local.get $fl + local.set $fl|6 + local.get $root|5 + local.get $fl|6 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.2 + end + i32.const 0 + i32.const -1 + i32.xor + local.get $sl + i32.shl + i32.and + local.set $slMap + i32.const 0 + local.set $head + local.get $slMap + i32.eqz + if + local.get $root + call $~lib/rt/tlsf/Root#get:flMap + i32.const 0 + i32.const -1 + i32.xor + local.get $fl + i32.const 1 + i32.add + i32.shl + i32.and + local.set $flMap + local.get $flMap + i32.eqz + if + i32.const 0 + local.set $head + else + local.get $flMap + i32.ctz + local.set $fl + block $~lib/rt/tlsf/GETSL|inlined.3 (result i32) + local.get $root + local.set $root|10 + local.get $fl + local.set $fl|11 + local.get $root|10 + local.get $fl|11 + i32.const 2 + i32.shl + i32.add + i32.load offset=4 + br $~lib/rt/tlsf/GETSL|inlined.3 + end + local.set $slMap + i32.const 1 + drop + local.get $slMap + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 347 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + block $~lib/rt/tlsf/GETHEAD|inlined.2 (result i32) + local.get $root + local.set $root|12 + local.get $fl + local.set $fl|13 + local.get $slMap + i32.ctz + local.set $sl|14 + local.get $root|12 + local.get $fl|13 + i32.const 4 + i32.shl + local.get $sl|14 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.2 + end + local.set $head + end + else + block $~lib/rt/tlsf/GETHEAD|inlined.3 (result i32) + local.get $root + local.set $root|15 + local.get $fl + local.set $fl|16 + local.get $slMap + i32.ctz + local.set $sl|17 + local.get $root|15 + local.get $fl|16 + i32.const 4 + i32.shl + local.get $sl|17 + i32.add + i32.const 2 + i32.shl + i32.add + i32.load offset=96 + br $~lib/rt/tlsf/GETHEAD|inlined.3 + end + local.set $head + end + local.get $head + return + ) + (func $~lib/rt/tlsf/growMemory (param $root i32) (param $size i32) + (local $pagesBefore i32) + (local $root|3 i32) + (local $pagesNeeded i32) + (local $5 i32) + (local $6 i32) + (local $pagesWanted i32) + (local $pagesAfter i32) + i32.const 0 + drop + local.get $size + i32.const 256 + i32.ge_u + if + local.get $size + call $~lib/rt/tlsf/roundSize + local.set $size + end + memory.size + local.set $pagesBefore + local.get $size + i32.const 4 + local.get $pagesBefore + i32.const 16 + i32.shl + i32.const 4 + i32.sub + block $~lib/rt/tlsf/GETTAIL|inlined.1 (result i32) + local.get $root + local.set $root|3 + local.get $root|3 + i32.load offset=1568 + br $~lib/rt/tlsf/GETTAIL|inlined.1 + end + i32.ne + i32.shl + i32.add + local.set $size + local.get $size + i32.const 65535 + i32.add + i32.const 65535 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.shr_u + local.set $pagesNeeded + local.get $pagesBefore + local.tee $5 + local.get $pagesNeeded + local.tee $6 + local.get $5 + local.get $6 + i32.gt_s + select + local.set $pagesWanted + local.get $pagesWanted + memory.grow + i32.const 0 + i32.lt_s + if + local.get $pagesNeeded + memory.grow + i32.const 0 + i32.lt_s + if + unreachable + end + end + memory.size + local.set $pagesAfter + local.get $root + local.get $pagesBefore + i32.const 16 + i32.shl + local.get $pagesAfter + i64.extend_i32_s + i64.const 16 + i64.shl + call $~lib/rt/tlsf/addMemory + drop + ) + (func $~lib/rt/tlsf/prepareBlock (param $root i32) (param $block i32) (param $size i32) + (local $blockInfo i32) + (local $remaining i32) + (local $spare i32) + (local $block|6 i32) + (local $block|7 i32) + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + local.set $blockInfo + i32.const 1 + drop + local.get $size + i32.const 4 + i32.add + i32.const 15 + i32.and + i32.eqz + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 361 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $blockInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $size + i32.sub + local.set $remaining + local.get $remaining + i32.const 4 + i32.const 12 + i32.add + i32.ge_u + if + local.get $block + local.get $size + local.get $blockInfo + i32.const 2 + i32.and + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $block + i32.const 4 + i32.add + local.get $size + i32.add + local.set $spare + local.get $spare + local.get $remaining + i32.const 4 + i32.sub + i32.const 1 + i32.or + call $~lib/rt/common/BLOCK#set:mmInfo + local.get $root + local.get $spare + call $~lib/rt/tlsf/insertBlock + else + local.get $block + local.get $blockInfo + i32.const 1 + i32.const -1 + i32.xor + i32.and + call $~lib/rt/common/BLOCK#set:mmInfo + block $~lib/rt/tlsf/GETRIGHT|inlined.3 (result i32) + local.get $block + local.set $block|7 + local.get $block|7 + i32.const 4 + i32.add + local.get $block|7 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.3 + end + block $~lib/rt/tlsf/GETRIGHT|inlined.2 (result i32) + local.get $block + local.set $block|6 + local.get $block|6 + i32.const 4 + i32.add + local.get $block|6 + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.add + br $~lib/rt/tlsf/GETRIGHT|inlined.2 + end + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 2 + i32.const -1 + i32.xor + i32.and + call $~lib/rt/common/BLOCK#set:mmInfo + end + ) + (func $~lib/rt/tlsf/allocateBlock (param $root i32) (param $size i32) (result i32) + (local $payloadSize i32) + (local $block i32) + local.get $size + call $~lib/rt/tlsf/prepareSize + local.set $payloadSize + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/searchBlock + local.set $block + local.get $block + i32.eqz + if + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/growMemory + local.get $root + local.get $payloadSize + call $~lib/rt/tlsf/searchBlock + local.set $block + i32.const 1 + drop + local.get $block + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 499 + i32.const 16 + call $~lib/builtins/abort + unreachable + end + end + i32.const 1 + drop + local.get $block + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + local.get $payloadSize + i32.ge_u + i32.eqz + if + i32.const 0 + i32.const 624 + i32.const 501 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $root + local.get $block + call $~lib/rt/tlsf/removeBlock + local.get $root + local.get $block + local.get $payloadSize + call $~lib/rt/tlsf/prepareBlock + i32.const 0 + drop + local.get $block + return + ) + (func $~lib/rt/tlsf/__alloc (param $size i32) (result i32) + global.get $~lib/rt/tlsf/ROOT + i32.eqz + if + call $~lib/rt/tlsf/initialize + end + global.get $~lib/rt/tlsf/ROOT + local.get $size + call $~lib/rt/tlsf/allocateBlock + i32.const 4 + i32.add + return + ) + (func $~lib/rt/itcms/Object#set:rtId (param $this i32) (param $rtId i32) + local.get $this + local.get $rtId + i32.store offset=12 + ) + (func $~lib/rt/itcms/Object#set:rtSize (param $this i32) (param $rtSize i32) + local.get $this + local.get $rtSize + i32.store offset=16 + ) + (func $~lib/rt/itcms/__new (param $size i32) (param $id i32) (result i32) + (local $obj i32) + (local $ptr i32) + local.get $size + i32.const 1073741804 + i32.ge_u + if + i32.const 288 + i32.const 352 + i32.const 261 + i32.const 31 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/rt/itcms/total + global.get $~lib/rt/itcms/threshold + i32.ge_u + if + call $~lib/rt/itcms/interrupt + end + i32.const 16 + local.get $size + i32.add + call $~lib/rt/tlsf/__alloc + i32.const 4 + i32.sub + local.set $obj + local.get $obj + local.get $id + call $~lib/rt/itcms/Object#set:rtId + local.get $obj + local.get $size + call $~lib/rt/itcms/Object#set:rtSize + local.get $obj + global.get $~lib/rt/itcms/fromSpace + global.get $~lib/rt/itcms/white + call $~lib/rt/itcms/Object#linkTo + global.get $~lib/rt/itcms/total + local.get $obj + call $~lib/rt/itcms/Object#get:size + i32.add + global.set $~lib/rt/itcms/total + local.get $obj + i32.const 20 + i32.add + local.set $ptr + local.get $ptr + i32.const 0 + local.get $size + memory.fill + local.get $ptr + return + ) + (func $assembly/arguments/Args#set:a (param $this i32) (param $a i32) + local.get $this + local.get $a + i32.store + ) + (func $assembly/arguments/Args#set:b (param $this i32) (param $b i32) + local.get $this + local.get $b + i32.store offset=4 + ) + (func $assembly/arguments/Args#set:c (param $this i32) (param $c i32) + local.get $this + local.get $c + i32.store offset=8 + ) + (func $assembly/arguments/Args#set:d (param $this i32) (param $d i32) + local.get $this + local.get $d + i32.store offset=12 + ) + (func $start:assembly/arguments~anonymous|0 (param $_d i32) (param $_l i32) (result i32) + i32.const 0 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + return + ) + (func $~lib/arraybuffer/ArrayBufferView#get:byteLength (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/arraybuffer/ArrayBufferView#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/rt/itcms/__link (param $parentPtr i32) (param $childPtr i32) (param $expectMultiple i32) + (local $child i32) + (local $parent i32) + (local $parentColor i32) + local.get $childPtr + i32.eqz + if + return + end + i32.const 1 + drop + local.get $parentPtr + i32.eqz + if + i32.const 0 + i32.const 352 + i32.const 295 + i32.const 14 + call $~lib/builtins/abort + unreachable + end + local.get $childPtr + i32.const 20 + i32.sub + local.set $child + local.get $child + call $~lib/rt/itcms/Object#get:color + global.get $~lib/rt/itcms/white + i32.eq + if + local.get $parentPtr + i32.const 20 + i32.sub + local.set $parent + local.get $parent + call $~lib/rt/itcms/Object#get:color + local.set $parentColor + local.get $parentColor + global.get $~lib/rt/itcms/white + i32.eqz + i32.eq + if + local.get $expectMultiple + if + local.get $parent + call $~lib/rt/itcms/Object#makeGray + else + local.get $child + call $~lib/rt/itcms/Object#makeGray + end + else + local.get $parentColor + i32.const 3 + i32.eq + if (result i32) + global.get $~lib/rt/itcms/state + i32.const 1 + i32.eq + else + i32.const 0 + end + if + local.get $child + call $~lib/rt/itcms/Object#makeGray + end + end + end + ) + (func $~lib/arraybuffer/ArrayBufferView#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/arguments/Nibbles#set:low (param $this i32) (param $low i32) + local.get $this + local.get $low + i32.store8 + ) + (func $assembly/arguments/Nibbles#set:hig (param $this i32) (param $hig i32) + local.get $this + local.get $hig + i32.store8 offset=1 + ) + (func $assembly/arguments/Nibbles#get:low (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/arguments/Nibbles#get:hig (param $this i32) (result i32) + local.get $this + i32.load8_u offset=1 + ) + (func $assembly/arguments/Args#get:a (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/arguments/Args#get:b (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $start:assembly/arguments + (local $0 i32) + (local $1 i32) + (local $2 i32) + memory.size + i32.const 16 + i32.shl + global.get $~lib/memory/__heap_base + i32.sub + i32.const 1 + i32.shr_u + global.set $~lib/rt/itcms/threshold + i32.const 400 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/pinSpace + i32.const 432 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/toSpace + i32.const 576 + call $~lib/rt/itcms/initLazy + global.set $~lib/rt/itcms/fromSpace + ) + (func $~lib/math/ipow32 (param $x i32) (param $e i32) (result i32) + (local $out i32) + (local $log i32) + (local $4 i32) + i32.const 1 + local.set $out + i32.const 0 + i32.const 1 + i32.lt_s + drop + local.get $x + i32.const 2 + i32.eq + if + i32.const 1 + local.get $e + i32.shl + i32.const 0 + local.get $e + i32.const 32 + i32.lt_u + select + return + end + local.get $e + i32.const 0 + i32.le_s + if + local.get $x + i32.const -1 + i32.eq + if + i32.const -1 + i32.const 1 + local.get $e + i32.const 1 + i32.and + select + return + end + local.get $e + i32.const 0 + i32.eq + local.get $x + i32.const 1 + i32.eq + i32.or + return + else + local.get $e + i32.const 1 + i32.eq + if + local.get $x + return + else + local.get $e + i32.const 2 + i32.eq + if + local.get $x + local.get $x + i32.mul + return + else + local.get $e + i32.const 32 + i32.lt_s + if + i32.const 32 + local.get $e + i32.clz + i32.sub + local.set $log + block $break|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $log + local.set $4 + local.get $4 + i32.const 5 + i32.eq + br_if $case0|0 + local.get $4 + i32.const 4 + i32.eq + br_if $case1|0 + local.get $4 + i32.const 3 + i32.eq + br_if $case2|0 + local.get $4 + i32.const 2 + i32.eq + br_if $case3|0 + local.get $4 + i32.const 1 + i32.eq + br_if $case4|0 + br $break|0 + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + end + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + end + local.get $out + return + end + end + end + end + loop $while-continue|1 + local.get $e + if + local.get $e + i32.const 1 + i32.and + if + local.get $out + local.get $x + i32.mul + local.set $out + end + local.get $e + i32.const 1 + i32.shr_u + local.set $e + local.get $x + local.get $x + i32.mul + local.set $x + br $while-continue|1 + end + end + local.get $out + return + ) + (func $start:assembly/memory-page + i32.const 2 + i32.const 16 + call $~lib/math/ipow32 + global.set $assembly/memory-page/SEGMENT_SIZE + global.get $assembly/memory-page/SEGMENT_SIZE + global.set $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/PAGE_SIZE + i32.div_u + global.set $assembly/memory-page/RESERVED_PAGES + i32.const 2 + i32.const 29 + call $~lib/math/ipow32 + global.set $assembly/memory-page/ALLOCATE_EAGERLY + ) + (func $assembly/memory/MaybePageFault#set:isFault (param $this i32) (param $isFault i32) + local.get $this + local.get $isFault + i32.store8 + ) + (func $assembly/memory/MaybePageFault#set:isAccess (param $this i32) (param $isAccess i32) + local.get $this + local.get $isAccess + i32.store8 offset=1 + ) + (func $assembly/memory/MaybePageFault#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store offset=4 + ) + (func $~lib/arraybuffer/ArrayBufferView#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/arraybuffer/ArrayBufferView#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/arraybuffer/ArrayBufferView#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $assembly/memory-page/Page#set:access (param $this i32) (param $access i32) + local.get $this + local.get $access + i32.store + ) + (func $assembly/memory-page/Page#set:raw (param $this i32) (param $raw i32) + local.get $this + local.get $raw + i32.store offset=4 + local.get $this + local.get $raw + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory-page/RawPage#set:id (param $this i32) (param $id i32) + local.get $this + local.get $id + i32.store + ) + (func $assembly/memory-page/RawPage#set:page (param $this i32) (param $page i32) + local.get $this + local.get $page + i32.store offset=4 + local.get $this + local.get $page + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/instructions/utils/reg (param $v i64) (result i32) + local.get $v + global.get $assembly/registers/NO_OF_REGISTERS + i64.extend_i32_s + i64.ge_u + if (result i32) + global.get $assembly/registers/NO_OF_REGISTERS + i32.const 1 + i32.sub + else + local.get $v + i32.wrap_i64 + end + return + ) + (func $~lib/rt/common/OBJECT#get:rtSize (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 3 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i64) + local.get $this + local.get $index + i32.const 3 + i32.shl + i32.add + local.get $value + i64.store + i32.const 0 + drop + ) + (func $assembly/instructions/outcome/OutcomeData#set:outcome (param $this i32) (param $outcome i32) + local.get $this + local.get $outcome + i32.store + ) + (func $assembly/instructions/outcome/OutcomeData#set:staticJump (param $this i32) (param $staticJump i32) + local.get $this + local.get $staticJump + i32.store offset=4 + ) + (func $assembly/instructions/outcome/OutcomeData#set:dJump (param $this i32) (param $dJump i32) + local.get $this + local.get $dJump + i32.store offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#set:result (param $this i32) (param $result i32) + local.get $this + local.get $result + i32.store offset=12 + ) + (func $assembly/instructions/outcome/OutcomeData#set:exitCode (param $this i32) (param $exitCode i32) + local.get $this + local.get $exitCode + i32.store offset=16 + ) + (func $assembly/instructions/outcome/ok (result i32) + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + return + ) + (func $assembly/instructions/utils/u8SignExtend (param $v i32) (result i64) + local.get $v + i32.extend8_s + i64.extend_i32_s + return + ) + (func $assembly/instructions/utils/u16SignExtend (param $v i32) (result i64) + local.get $v + i32.extend16_s + i64.extend_i32_s + return + ) + (func $~lib/polyfills/bswap (param $value i64) (result i64) + (local $a i64) + (local $b i64) + (local $v i64) + i32.const 1 + drop + i32.const 8 + i32.const 1 + i32.eq + drop + i32.const 8 + i32.const 2 + i32.eq + drop + i32.const 8 + i32.const 4 + i32.eq + drop + i32.const 8 + i32.const 8 + i32.eq + drop + local.get $value + i64.const 8 + i64.shr_u + i64.const 71777214294589695 + i64.and + local.set $a + local.get $value + i64.const 71777214294589695 + i64.and + i64.const 8 + i64.shl + local.set $b + local.get $a + local.get $b + i64.or + local.set $v + local.get $v + i64.const 16 + i64.shr_u + i64.const 281470681808895 + i64.and + local.set $a + local.get $v + i64.const 281470681808895 + i64.and + i64.const 16 + i64.shl + local.set $b + local.get $a + local.get $b + i64.or + i64.const 32 + i64.rotr + return + ) + (func $assembly/registers/newRegisters (result i32) + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + return + ) + (func $"~lib/map/Map#set:buckets" (param $this i32) (param $buckets i32) + local.get $this + local.get $buckets + i32.store + local.get $this + local.get $buckets + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $"~lib/map/Map#set:bucketsMask" (param $this i32) (param $bucketsMask i32) + local.get $this + local.get $bucketsMask + i32.store offset=4 + ) + (func $"~lib/map/Map#set:entries" (param $this i32) (param $entries i32) + local.get $this + local.get $entries + i32.store offset=8 + local.get $this + local.get $entries + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $"~lib/map/Map#set:entriesCapacity" (param $this i32) (param $entriesCapacity i32) + local.get $this + local.get $entriesCapacity + i32.store offset=12 + ) + (func $"~lib/map/Map#set:entriesOffset" (param $this i32) (param $entriesOffset i32) + local.get $this + local.get $entriesOffset + i32.store offset=16 + ) + (func $"~lib/map/Map#set:entriesCount" (param $this i32) (param $entriesCount i32) + local.get $this + local.get $entriesCount + i32.store offset=20 + ) + (func $assembly/memory/MemoryBuilder#set:pages (param $this i32) (param $pages i32) + local.get $this + local.get $pages + i32.store + local.get $this + local.get $pages + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory-page/Arena#set:arenaBytes (param $this i32) (param $arenaBytes i32) + local.get $this + local.get $arenaBytes + i32.store offset=4 + ) + (func $~lib/rt/__newBuffer (param $size i32) (param $id i32) (param $data i32) (result i32) + (local $buffer i32) + local.get $size + local.get $id + call $~lib/rt/itcms/__new + local.set $buffer + local.get $data + if + local.get $buffer + local.get $data + local.get $size + memory.copy + end + local.get $buffer + return + ) + (func $assembly/memory-page/Arena#set:free (param $this i32) (param $free i32) + local.get $this + local.get $free + i32.store + local.get $this + local.get $free + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory-page/Arena#set:extraPageIndex (param $this i32) (param $extraPageIndex i32) + local.get $this + local.get $extraPageIndex + i32.store offset=8 + ) + (func $assembly/memory-page/Arena#get:arenaBytes (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Arena#get:free (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/arraybuffer/ArrayBuffer#get:byteLength (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + return + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/rt/itcms/Object#get:rtSize (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $~lib/rt/itcms/__renew (param $oldPtr i32) (param $size i32) (result i32) + (local $oldObj i32) + (local $newPtr i32) + (local $4 i32) + (local $5 i32) + local.get $oldPtr + i32.const 20 + i32.sub + local.set $oldObj + local.get $size + local.get $oldObj + call $~lib/rt/common/BLOCK#get:mmInfo + i32.const 3 + i32.const -1 + i32.xor + i32.and + i32.const 16 + i32.sub + i32.le_u + if + local.get $oldObj + local.get $size + call $~lib/rt/itcms/Object#set:rtSize + local.get $oldPtr + return + end + local.get $size + local.get $oldObj + call $~lib/rt/itcms/Object#get:rtId + call $~lib/rt/itcms/__new + local.set $newPtr + local.get $newPtr + local.get $oldPtr + local.get $size + local.tee $4 + local.get $oldObj + call $~lib/rt/itcms/Object#get:rtSize + local.tee $5 + local.get $4 + local.get $5 + i32.lt_u + select + memory.copy + local.get $newPtr + return + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $assembly/memory/MemoryBuilder#set:arena (param $this i32) (param $arena i32) + local.get $this + local.get $arena + i32.store offset=4 + local.get $this + local.get $arena + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/util/hash/HASH (param $key i32) (result i32) + (local $key|1 i32) + (local $len i32) + (local $h i32) + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 4 + i32.const 4 + i32.le_u + drop + block $~lib/util/hash/hash32|inlined.0 (result i32) + local.get $key + local.set $key|1 + i32.const 4 + local.set $len + i32.const 0 + i32.const 374761393 + i32.add + local.get $len + i32.add + local.set $h + local.get $h + local.get $key|1 + i32.const -1028477379 + i32.mul + i32.add + local.set $h + local.get $h + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 15 + i32.shr_u + i32.xor + local.set $h + local.get $h + i32.const -2048144777 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 13 + i32.shr_u + i32.xor + local.set $h + local.get $h + i32.const -1028477379 + i32.mul + local.set $h + local.get $h + local.get $h + i32.const 16 + i32.shr_u + i32.xor + local.set $h + local.get $h + br $~lib/util/hash/hash32|inlined.0 + end + return + ) + (func $"~lib/map/Map#get:buckets" (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $"~lib/map/Map#get:bucketsMask" (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $"~lib/map/MapEntry#get:taggedNext" (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#get:key" (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/Memory#set:lastAllocatedPage (param $this i32) (param $lastAllocatedPage i32) + local.get $this + local.get $lastAllocatedPage + i32.store + ) + (func $assembly/memory/Memory#set:arena (param $this i32) (param $arena i32) + local.get $this + local.get $arena + i32.store offset=4 + local.get $this + local.get $arena + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Memory#set:pages (param $this i32) (param $pages i32) + local.get $this + local.get $pages + i32.store offset=8 + local.get $this + local.get $pages + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Memory#set:sbrkAddress (param $this i32) (param $sbrkAddress i32) + local.get $this + local.get $sbrkAddress + i32.store offset=12 + ) + (func $assembly/memory/MemoryBuilder#get:arena (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/MemoryBuilder#get:pages (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/test/Assert#set:isOkay (param $this i32) (param $isOkay i32) + local.get $this + local.get $isOkay + i32.store8 + ) + (func $assembly/test/Assert#set:errors (param $this i32) (param $errors i32) + local.get $this + local.get $errors + i32.store offset=4 + local.get $this + local.get $errors + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/instructions/outcome/OutcomeData#get:outcome (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/util/number/decimalCount32 (param $value i32) (result i32) + local.get $value + i32.const 100000 + i32.lt_u + if + local.get $value + i32.const 100 + i32.lt_u + if + i32.const 1 + local.get $value + i32.const 10 + i32.ge_u + i32.add + return + else + i32.const 3 + local.get $value + i32.const 10000 + i32.ge_u + i32.add + local.get $value + i32.const 1000 + i32.ge_u + i32.add + return + end + unreachable + else + local.get $value + i32.const 10000000 + i32.lt_u + if + i32.const 6 + local.get $value + i32.const 1000000 + i32.ge_u + i32.add + return + else + i32.const 8 + local.get $value + i32.const 1000000000 + i32.ge_u + i32.add + local.get $value + i32.const 100000000 + i32.ge_u + i32.add + return + end + unreachable + end + unreachable + ) + (func $~lib/util/number/utoa32_dec_lut (param $buffer i32) (param $num i32) (param $offset i32) + (local $t i32) + (local $r i32) + (local $d1 i32) + (local $d2 i32) + (local $digits1 i64) + (local $digits2 i64) + (local $t|9 i32) + (local $d1|10 i32) + (local $digits i32) + (local $digits|12 i32) + (local $digit i32) + loop $while-continue|0 + local.get $num + i32.const 10000 + i32.ge_u + if + local.get $num + i32.const 10000 + i32.div_u + local.set $t + local.get $num + i32.const 10000 + i32.rem_u + local.set $r + local.get $t + local.set $num + local.get $r + i32.const 100 + i32.div_u + local.set $d1 + local.get $r + i32.const 100 + i32.rem_u + local.set $d2 + i32.const 2508 + local.get $d1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 2508 + local.get $d2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $num + i32.const 100 + i32.ge_u + if + local.get $num + i32.const 100 + i32.div_u + local.set $t|9 + local.get $num + i32.const 100 + i32.rem_u + local.set $d1|10 + local.get $t|9 + local.set $num + local.get $offset + i32.const 2 + i32.sub + local.set $offset + i32.const 2508 + local.get $d1|10 + i32.const 2 + i32.shl + i32.add + i32.load + local.set $digits + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits + i32.store + end + local.get $num + i32.const 10 + i32.ge_u + if + local.get $offset + i32.const 2 + i32.sub + local.set $offset + i32.const 2508 + local.get $num + i32.const 2 + i32.shl + i32.add + i32.load + local.set $digits|12 + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits|12 + i32.store + else + local.get $offset + i32.const 1 + i32.sub + local.set $offset + i32.const 48 + local.get $num + i32.add + local.set $digit + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digit + i32.store16 + end + ) + (func $~lib/util/number/utoa_hex_lut (param $buffer i32) (param $num i64) (param $offset i32) + loop $while-continue|0 + local.get $offset + i32.const 2 + i32.ge_u + if + local.get $offset + i32.const 2 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 2928 + local.get $num + i32.wrap_i64 + i32.const 255 + i32.and + i32.const 2 + i32.shl + i32.add + i32.load + i32.store + local.get $num + i64.const 8 + i64.shr_u + local.set $num + br $while-continue|0 + end + end + local.get $offset + i32.const 1 + i32.and + if + local.get $buffer + i32.const 2928 + local.get $num + i32.wrap_i64 + i32.const 6 + i32.shl + i32.add + i32.load16_u + i32.store16 + end + ) + (func $~lib/util/number/ulog_base (param $num i64) (param $base i32) (result i32) + (local $value i32) + (local $b64 i64) + (local $b i64) + (local $e i32) + block $~lib/util/number/isPowerOf2|inlined.0 (result i32) + local.get $base + local.set $value + local.get $value + i32.popcnt + i32.const 1 + i32.eq + br $~lib/util/number/isPowerOf2|inlined.0 + end + if + i32.const 63 + local.get $num + i64.clz + i32.wrap_i64 + i32.sub + i32.const 31 + local.get $base + i32.clz + i32.sub + i32.div_u + i32.const 1 + i32.add + return + end + local.get $base + i64.extend_i32_s + local.set $b64 + local.get $b64 + local.set $b + i32.const 1 + local.set $e + loop $while-continue|0 + local.get $num + local.get $b + i64.ge_u + if + local.get $num + local.get $b + i64.div_u + local.set $num + local.get $b + local.get $b + i64.mul + local.set $b + local.get $e + i32.const 1 + i32.shl + local.set $e + br $while-continue|0 + end + end + loop $while-continue|1 + local.get $num + i64.const 1 + i64.ge_u + if + local.get $num + local.get $b64 + i64.div_u + local.set $num + local.get $e + i32.const 1 + i32.add + local.set $e + br $while-continue|1 + end + end + local.get $e + i32.const 1 + i32.sub + return + ) + (func $~lib/util/number/utoa64_any_core (param $buffer i32) (param $num i64) (param $offset i32) (param $radix i32) + (local $base i64) + (local $shift i64) + (local $mask i64) + (local $q i64) + local.get $radix + i64.extend_i32_s + local.set $base + local.get $radix + local.get $radix + i32.const 1 + i32.sub + i32.and + i32.const 0 + i32.eq + if + local.get $radix + i32.ctz + i32.const 7 + i32.and + i64.extend_i32_s + local.set $shift + local.get $base + i64.const 1 + i64.sub + local.set $mask + loop $do-loop|0 + local.get $offset + i32.const 1 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 3984 + local.get $num + local.get $mask + i64.and + i32.wrap_i64 + i32.const 1 + i32.shl + i32.add + i32.load16_u + i32.store16 + local.get $num + local.get $shift + i64.shr_u + local.set $num + local.get $num + i64.const 0 + i64.ne + br_if $do-loop|0 + end + else + loop $do-loop|1 + local.get $offset + i32.const 1 + i32.sub + local.set $offset + local.get $num + local.get $base + i64.div_u + local.set $q + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + i32.const 3984 + local.get $num + local.get $q + local.get $base + i64.mul + i64.sub + i32.wrap_i64 + i32.const 1 + i32.shl + i32.add + i32.load16_u + i32.store16 + local.get $q + local.set $num + local.get $num + i64.const 0 + i64.ne + br_if $do-loop|1 + end + end + ) + (func $~lib/number/I32#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/itoa32 + return + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/string/String#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 1 + i32.shr_u + return + ) + (func $assembly/test/Assert#get:errors (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array<~lib/string/String>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array<~lib/string/String>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array<~lib/string/String>#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/util/number/decimalCount64High (param $value i64) (result i32) + local.get $value + i64.const 1000000000000000 + i64.lt_u + if + local.get $value + i64.const 1000000000000 + i64.lt_u + if + i32.const 10 + local.get $value + i64.const 100000000000 + i64.ge_u + i32.add + local.get $value + i64.const 10000000000 + i64.ge_u + i32.add + return + else + i32.const 13 + local.get $value + i64.const 100000000000000 + i64.ge_u + i32.add + local.get $value + i64.const 10000000000000 + i64.ge_u + i32.add + return + end + unreachable + else + local.get $value + i64.const 100000000000000000 + i64.lt_u + if + i32.const 16 + local.get $value + i64.const 10000000000000000 + i64.ge_u + i32.add + return + else + i32.const 18 + local.get $value + i64.const -8446744073709551616 + i64.ge_u + i32.add + local.get $value + i64.const 1000000000000000000 + i64.ge_u + i32.add + return + end + unreachable + end + unreachable + ) + (func $~lib/util/number/utoa64_dec_lut (param $buffer i32) (param $num i64) (param $offset i32) + (local $t i64) + (local $r i32) + (local $b i32) + (local $c i32) + (local $b1 i32) + (local $b2 i32) + (local $c1 i32) + (local $c2 i32) + (local $digits1 i64) + (local $digits2 i64) + loop $while-continue|0 + local.get $num + i64.const 100000000 + i64.ge_u + if + local.get $num + i64.const 100000000 + i64.div_u + local.set $t + local.get $num + local.get $t + i64.const 100000000 + i64.mul + i64.sub + i32.wrap_i64 + local.set $r + local.get $t + local.set $num + local.get $r + i32.const 10000 + i32.div_u + local.set $b + local.get $r + i32.const 10000 + i32.rem_u + local.set $c + local.get $b + i32.const 100 + i32.div_u + local.set $b1 + local.get $b + i32.const 100 + i32.rem_u + local.set $b2 + local.get $c + i32.const 100 + i32.div_u + local.set $c1 + local.get $c + i32.const 100 + i32.rem_u + local.set $c2 + i32.const 2508 + local.get $c1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 2508 + local.get $c2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + i32.const 2508 + local.get $b1 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits1 + i32.const 2508 + local.get $b2 + i32.const 2 + i32.shl + i32.add + i64.load32_u + local.set $digits2 + local.get $offset + i32.const 4 + i32.sub + local.set $offset + local.get $buffer + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $digits1 + local.get $digits2 + i64.const 32 + i64.shl + i64.or + i64.store + br $while-continue|0 + end + end + local.get $buffer + local.get $num + i32.wrap_i64 + local.get $offset + call $~lib/util/number/utoa32_dec_lut + ) + (func $~lib/number/U64#toString (param $this i64) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/utoa64 + return + ) + (func $assembly/test/Test#set:name (param $this i32) (param $name i32) + local.get $this + local.get $name + i32.store + local.get $this + local.get $name + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/test/Test#set:ptr (param $this i32) (param $ptr i32) + local.get $this + local.get $ptr + i32.store offset=4 + local.get $this + local.get $ptr + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/number/I64#toString (param $this i64) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/itoa64 + return + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/utils/u32SignExtend (param $v i32) (result i64) + local.get $v + i64.extend_i32_s + return + ) + (func $assembly/arguments/Args#get:c (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#get:staticJump (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/number/U32#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/utoa32 + return + ) + (func $~lib/math/ipow64 (param $x i64) (param $e i64) (result i64) + (local $out i64) + (local $log i32) + (local $4 i32) + i64.const 1 + local.set $out + i32.const 0 + i32.const 1 + i32.lt_s + drop + local.get $x + i64.const 2 + i64.eq + if + i64.const 1 + local.get $e + i64.shl + i64.const 0 + local.get $e + i64.const 64 + i64.lt_u + select + return + end + local.get $e + i64.const 0 + i64.le_s + if + local.get $x + i64.const -1 + i64.eq + if + i64.const -1 + i64.const 1 + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + select + return + end + local.get $e + i64.const 0 + i64.eq + i64.extend_i32_u + local.get $x + i64.const 1 + i64.eq + i64.extend_i32_u + i64.or + return + else + local.get $e + i64.const 1 + i64.eq + if + local.get $x + return + else + local.get $e + i64.const 2 + i64.eq + if + local.get $x + local.get $x + i64.mul + return + else + local.get $e + i64.const 64 + i64.lt_s + if + i32.const 64 + local.get $e + i64.clz + i32.wrap_i64 + i32.sub + local.set $log + block $break|0 + block $case5|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $log + local.set $4 + local.get $4 + i32.const 6 + i32.eq + br_if $case0|0 + local.get $4 + i32.const 5 + i32.eq + br_if $case1|0 + local.get $4 + i32.const 4 + i32.eq + br_if $case2|0 + local.get $4 + i32.const 3 + i32.eq + br_if $case3|0 + local.get $4 + i32.const 2 + i32.eq + br_if $case4|0 + local.get $4 + i32.const 1 + i32.eq + br_if $case5|0 + br $break|0 + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + end + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + end + local.get $out + return + end + end + end + end + loop $while-continue|1 + local.get $e + i64.const 0 + i64.ne + if + local.get $e + i64.const 1 + i64.and + i64.const 0 + i64.ne + if + local.get $out + local.get $x + i64.mul + local.set $out + end + local.get $e + i64.const 1 + i64.shr_u + local.set $e + local.get $x + local.get $x + i64.mul + local.set $x + br $while-continue|1 + end + end + local.get $out + return + ) + (func $assembly/instructions/utils/mulUpperUnsigned (param $a i64) (param $b i64) (result i64) + (local $aHigh i64) + (local $aLow i64) + (local $bHigh i64) + (local $bLow i64) + (local $lowLow i64) + (local $lowHigh i64) + (local $highLow i64) + (local $highHigh i64) + (local $carry i64) + local.get $a + i64.const 32 + i64.shr_u + local.set $aHigh + local.get $a + i64.const 4294967295 + i64.and + local.set $aLow + local.get $b + i64.const 32 + i64.shr_u + local.set $bHigh + local.get $b + i64.const 4294967295 + i64.and + local.set $bLow + local.get $aLow + local.get $bLow + i64.mul + local.set $lowLow + local.get $aLow + local.get $bHigh + i64.mul + local.set $lowHigh + local.get $aHigh + local.get $bLow + i64.mul + local.set $highLow + local.get $aHigh + local.get $bHigh + i64.mul + local.set $highHigh + local.get $lowLow + i64.const 32 + i64.shr_u + local.get $lowHigh + i64.const 4294967295 + i64.and + i64.add + local.get $highLow + i64.const 4294967295 + i64.and + i64.add + local.set $carry + local.get $highHigh + local.get $lowHigh + i64.const 32 + i64.shr_u + i64.add + local.get $highLow + i64.const 32 + i64.shr_u + i64.add + local.get $carry + i64.const 32 + i64.shr_u + i64.add + return + ) + (func $assembly/instructions/utils/mulUpperSigned (param $a i64) (param $b i64) (result i64) + (local $isResultNegative i32) + (local $aAbs i64) + (local $bAbs i64) + (local $upper i64) + (local $lower i64) + i32.const 0 + local.set $isResultNegative + local.get $a + local.set $aAbs + local.get $b + local.set $bAbs + local.get $a + i64.const 0 + i64.lt_s + if + local.get $isResultNegative + i32.eqz + local.set $isResultNegative + local.get $a + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $aAbs + end + local.get $b + i64.const 0 + i64.lt_s + if + local.get $isResultNegative + i32.eqz + local.set $isResultNegative + local.get $b + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $bAbs + end + local.get $isResultNegative + if + local.get $aAbs + local.get $bAbs + call $assembly/instructions/utils/mulUpperUnsigned + local.set $upper + local.get $aAbs + local.get $bAbs + i64.mul + local.set $lower + local.get $upper + i64.const -1 + i64.xor + local.get $lower + i64.const 0 + i64.eq + if (result i64) + i64.const 1 + else + i64.const 0 + end + i64.add + return + end + local.get $aAbs + local.get $bAbs + call $assembly/instructions/utils/mulUpperUnsigned + return + ) + (func $assembly/instructions/utils/mulUpperSignedUnsigned (param $a i64) (param $b i64) (result i64) + (local $aAbs i64) + (local $upper i64) + (local $lower i64) + local.get $a + i64.const 0 + i64.lt_s + if + local.get $a + i64.const -1 + i64.xor + i64.const 1 + i64.add + local.set $aAbs + local.get $aAbs + local.get $b + call $assembly/instructions/utils/mulUpperUnsigned + local.set $upper + local.get $aAbs + local.get $b + i64.mul + local.set $lower + local.get $upper + i64.const -1 + i64.xor + local.get $lower + i64.const 0 + i64.eq + if (result i64) + i64.const 1 + else + i64.const 0 + end + i64.add + return + end + local.get $a + local.get $b + call $assembly/instructions/utils/mulUpperUnsigned + return + ) + (func $assembly/instructions/rot/math.rot_r (param $v i64) (param $shift i64) (result i64) + local.get $v + local.get $shift + i64.rotr + return + ) + (func $assembly/instructions/rot/math.rot_r_32 (param $v i32) (param $shift i32) (result i32) + local.get $v + local.get $shift + i32.rotr + return + ) + (func $assembly/instructions/rot/math.rot_l (param $v i64) (param $shift i64) (result i64) + local.get $v + local.get $shift + i64.rotl + return + ) + (func $assembly/instructions/rot/math.rot_l_32 (param $v i32) (param $shift i32) (result i32) + local.get $v + local.get $shift + i32.rotl + return + ) + (func $assembly/memory/Chunks#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#set:first (param $this i32) (param $first i32) + local.get $this + local.get $first + i32.store offset=4 + local.get $this + local.get $first + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#set:second (param $this i32) (param $second i32) + local.get $this + local.get $second + i32.store offset=8 + local.get $this + local.get $second + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Memory#get:pages (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/memory/PageData#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/PageData#set:page (param $this i32) (param $page i32) + local.get $this + local.get $page + i32.store offset=4 + local.get $this + local.get $page + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/PageData#set:relativeAddress (param $this i32) (param $relativeAddress i32) + local.get $this + local.get $relativeAddress + i32.store offset=8 + ) + (func $"~lib/map/MapEntry#get:value" (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Page#get:access (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/PageData#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/MaybePageFault#get:isFault (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/memory/PageData#get:page (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/PageData#get:relativeAddress (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/memory-page/Page#get:raw (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/RawPage#get:page (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i32) (param $start i32) (param $end i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + local.get $start + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $start + i32.add + local.tee $5 + i32.const 0 + local.tee $6 + local.get $5 + local.get $6 + i32.gt_u + select + else + local.get $start + local.tee $7 + local.get $len + local.tee $8 + local.get $7 + local.get $8 + i32.lt_s + select + end + local.set $start + local.get $end + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $end + i32.add + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_u + select + else + local.get $end + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + end + local.set $end + i32.const 1 + i32.const 1 + i32.eq + drop + local.get $start + local.get $end + i32.lt_s + if + local.get $ptr + local.get $start + i32.add + local.get $value + local.get $end + local.get $start + i32.sub + memory.fill + end + ) + (func $assembly/memory/Chunks#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/ChunkBytes#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/ChunkBytes#set:bytes (param $this i32) (param $bytes i32) + local.get $this + local.get $bytes + i32.store offset=4 + local.get $this + local.get $bytes + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/Chunks#get:first (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/Chunks#get:second (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 0 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + i32.const 0 + drop + ) + (func $assembly/memory/Result#set:ok (param $this i32) (param $ok i64) + local.get $this + local.get $ok + i64.store + ) + (func $assembly/memory/Result#set:fault (param $this i32) (param $fault i32) + local.get $this + local.get $fault + i32.store offset=8 + local.get $this + local.get $fault + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/memory/ChunkBytes#get:fault (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/ChunkBytes#get:bytes (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory/Result#get:ok (param $this i32) (result i64) + local.get $this + i64.load + ) + (func $assembly/memory/Result#get:fault (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/number/Bool#toString (param $this i32) (param $radix i32) (result i32) + local.get $this + if (result i32) + i32.const 9040 + else + i32.const 9072 + end + return + ) + (func $assembly/memory/MaybePageFault#get:isAccess (param $this i32) (result i32) + local.get $this + i32.load8_u offset=1 + ) + (func $assembly/memory/MaybePageFault#get:fault (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/memory-page/Arena#get:extraPageIndex (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#set:value" (param $this i32) (param $value i32) + local.get $this + local.get $value + i32.store offset=4 + ) + (func $"~lib/map/Map#get:entriesOffset" (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $"~lib/map/Map#get:entriesCapacity" (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $"~lib/map/Map#get:entriesCount" (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $"~lib/map/Map#get:entries" (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#set:key" (param $this i32) (param $key i32) + local.get $this + local.get $key + i32.store + ) + (func $"~lib/map/MapEntry#set:taggedNext" (param $this i32) (param $taggedNext i32) + local.get $this + local.get $taggedNext + i32.store offset=8 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i32) (result i32) + (local $sign i32) + (local $dest i32) + (local $decimals i32) + (local $val32 i32) + (local $buffer|6 i32) + (local $num i32) + (local $offset i32) + i32.const 0 + local.set $sign + i32.const 0 + drop + local.get $buffer + local.get $sign + i32.const 1 + i32.shl + i32.add + local.set $dest + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 0 + drop + local.get $value + i32.const 255 + i32.and + i32.const 10 + i32.lt_u + if + local.get $buffer + local.get $value + i32.const 255 + i32.and + i32.const 48 + i32.or + i32.store16 + i32.const 1 + return + end + i32.const 0 + local.set $decimals + i32.const 1 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 255 + i32.and + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + local.get $dest + local.set $buffer|6 + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|6 + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + local.get $sign + local.get $decimals + i32.add + return + ) + (func $~lib/util/string/compareImpl (param $str1 i32) (param $index1 i32) (param $str2 i32) (param $index2 i32) (param $len i32) (result i32) + (local $ptr1 i32) + (local $ptr2 i32) + (local $7 i32) + (local $a i32) + (local $b i32) + local.get $str1 + local.get $index1 + i32.const 1 + i32.shl + i32.add + local.set $ptr1 + local.get $str2 + local.get $index2 + i32.const 1 + i32.shl + i32.add + local.set $ptr2 + i32.const 0 + i32.const 2 + i32.lt_s + drop + local.get $len + i32.const 4 + i32.ge_u + if (result i32) + local.get $ptr1 + i32.const 7 + i32.and + local.get $ptr2 + i32.const 7 + i32.and + i32.or + i32.eqz + else + i32.const 0 + end + if + block $do-break|0 + loop $do-loop|0 + local.get $ptr1 + i64.load + local.get $ptr2 + i64.load + i64.ne + if + br $do-break|0 + end + local.get $ptr1 + i32.const 8 + i32.add + local.set $ptr1 + local.get $ptr2 + i32.const 8 + i32.add + local.set $ptr2 + local.get $len + i32.const 4 + i32.sub + local.set $len + local.get $len + i32.const 4 + i32.ge_u + br_if $do-loop|0 + end + end + end + loop $while-continue|1 + local.get $len + local.tee $7 + i32.const 1 + i32.sub + local.set $len + local.get $7 + if + local.get $ptr1 + i32.load16_u + local.set $a + local.get $ptr2 + i32.load16_u + local.set $b + local.get $a + local.get $b + i32.ne + if + local.get $a + local.get $b + i32.sub + return + end + local.get $ptr1 + i32.const 2 + i32.add + local.set $ptr1 + local.get $ptr2 + i32.const 2 + i32.add + local.set $ptr2 + br $while-continue|1 + end + end + i32.const 0 + return + ) + (func $assembly/arguments/Args#get:d (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/instructions/outcome/panic (result i32) + global.get $assembly/instructions/outcome/Result.PANIC + call $assembly/instructions/outcome/status + return + ) + (func $start:assembly/instructions/misc~anonymous|0 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/panic + ) + (func $start:assembly/instructions/misc~anonymous|1 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/panic + ) + (func $start:assembly/instructions/misc~anonymous|2 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) + call $assembly/instructions/outcome/ok + ) + (func $assembly/memory/Memory#get:sbrkAddress (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/memory/Memory#get:lastAllocatedPage (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/memory/Memory#get:arena (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/Instruction#set:namePtr (param $this i32) (param $namePtr i32) + local.get $this + local.get $namePtr + i32.store + ) + (func $assembly/instructions/Instruction#set:kind (param $this i32) (param $kind i32) + local.get $this + local.get $kind + i32.store offset=4 + ) + (func $assembly/instructions/Instruction#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=8 + ) + (func $assembly/instructions/Instruction#set:isTerminating (param $this i32) (param $isTerminating i32) + local.get $this + local.get $isTerminating + i32.store8 offset=16 + ) + (func $assembly/instructions/Instruction#constructor (param $this i32) (result i32) + local.get $this + i32.eqz + if + i32.const 17 + call $~lib/rt/tlsf/__alloc + local.set $this + end + local.get $this + i32.const 0 + call $assembly/instructions/Instruction#set:namePtr + local.get $this + global.get $assembly/arguments/Arguments.Zero + call $assembly/instructions/Instruction#set:kind + local.get $this + i64.const 0 + call $assembly/instructions/Instruction#set:gas + local.get $this + i32.const 0 + call $assembly/instructions/Instruction#set:isTerminating + local.get $this + ) + (func $assembly/instructions/instruction (param $name i32) (param $kind i32) (param $gas i64) (param $isTerminating i32) (result i32) + (local $i i32) + i32.const 0 + call $assembly/instructions/Instruction#constructor + local.set $i + local.get $i + local.get $name + call $assembly/instructions/Instruction#set:namePtr + local.get $i + local.get $kind + call $assembly/instructions/Instruction#set:kind + local.get $i + local.get $gas + call $assembly/instructions/Instruction#set:gas + local.get $i + local.get $isTerminating + call $assembly/instructions/Instruction#set:isTerminating + local.get $i + return + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $start:assembly/program + call $start:assembly/instructions + ) + (func $assembly/program/Mask#set:bytesToSkip (param $this i32) (param $bytesToSkip i32) + local.get $this + local.get $bytesToSkip + i32.store + local.get $this + local.get $bytesToSkip + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Mask#get:bytesToSkip (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i32) (result i32) + (local $sign i32) + (local $dest i32) + (local $decimals i32) + (local $val32 i32) + (local $buffer|6 i32) + (local $num i32) + (local $offset i32) + i32.const 0 + local.set $sign + i32.const 0 + drop + local.get $buffer + local.get $sign + i32.const 1 + i32.shl + i32.add + local.set $dest + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 0 + drop + local.get $value + i32.const 10 + i32.lt_u + if + local.get $buffer + local.get $value + i32.const 48 + i32.or + i32.store16 + i32.const 1 + return + end + i32.const 0 + local.set $decimals + i32.const 4 + i32.const 4 + i32.le_u + drop + local.get $value + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + local.get $dest + local.set $buffer|6 + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|6 + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + local.get $sign + local.get $decimals + i32.add + return + ) + (func $~lib/string/String#toString (param $this i32) (result i32) + local.get $this + return + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/codec/Decoder#set:source (param $this i32) (param $source i32) + local.get $this + local.get $source + i32.store + local.get $this + local.get $source + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/codec/Decoder#set:offset (param $this i32) (param $offset i32) + local.get $this + local.get $offset + i32.store offset=4 + ) + (func $assembly/codec/Decoder#get:offset (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/codec/Decoder#get:source (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/codec/ValOffset#set:value (param $this i32) (param $value i32) + local.get $this + local.get $value + i32.store + ) + (func $assembly/codec/ValOffset#set:offset (param $this i32) (param $offset i32) + local.get $this + local.get $offset + i32.store offset=4 + ) + (func $assembly/codec/ValOffset#get:offset (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/codec/ValOffset#get:value (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/JumpTable#set:jumps (param $this i32) (param $jumps i32) + local.get $this + local.get $jumps + i32.store + local.get $this + local.get $jumps + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return + ) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + ) + (func $assembly/instructions/Instruction#get:isTerminating (param $this i32) (result i32) + local.get $this + i32.load8_u offset=16 + ) + (func $assembly/program/BasicBlocks#set:isStartOrEnd (param $this i32) (param $isStartOrEnd i32) + local.get $this + local.get $isStartOrEnd + i32.store + local.get $this + local.get $isStartOrEnd + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:code (param $this i32) (param $code i32) + local.get $this + local.get $code + i32.store + local.get $this + local.get $code + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:mask (param $this i32) (param $mask i32) + local.get $this + local.get $mask + i32.store offset=4 + local.get $this + local.get $mask + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:jumpTable (param $this i32) (param $jumpTable i32) + local.get $this + local.get $jumpTable + i32.store offset=8 + local.get $this + local.get $jumpTable + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#set:basicBlocks (param $this i32) (param $basicBlocks i32) + local.get $this + local.get $basicBlocks + i32.store offset=12 + local.get $this + local.get $basicBlocks + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/Program#get:mask (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/program/Program#get:jumpTable (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/program/JumpTable#get:jumps (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/program/Program#get:basicBlocks (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/program/BasicBlocks#get:isStartOrEnd (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $start:assembly/spi + i32.const 2 + i32.const 24 + call $~lib/math/ipow32 + global.set $assembly/spi/DATA_LENGTH + i32.const 2 + i32.const 32 + call $~lib/math/ipow32 + global.get $assembly/memory-page/SEGMENT_SIZE + i32.sub + global.get $assembly/spi/DATA_LENGTH + i32.sub + global.set $assembly/spi/ARGS_SEGMENT_START + i32.const 2 + i32.const 32 + call $~lib/math/ipow32 + i32.const 2 + global.get $assembly/memory-page/SEGMENT_SIZE + i32.mul + i32.sub + global.get $assembly/spi/DATA_LENGTH + i32.sub + global.set $assembly/spi/STACK_SEGMENT_END + ) + (func $assembly/spi/alignToSegmentSize (param $size i32) (result i32) + local.get $size + global.get $assembly/memory-page/SEGMENT_SIZE + i32.add + i32.const 1 + i32.sub + global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT + i32.shr_u + global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT + i32.shl + return + ) + (func $assembly/spi/alignToPageSize (param $size i32) (result i32) + local.get $size + global.get $assembly/memory-page/PAGE_SIZE + i32.add + i32.const 1 + i32.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + return + ) + (func $assembly/spi/StandardProgram#set:program (param $this i32) (param $program i32) + local.get $this + local.get $program + i32.store offset=16 + local.get $this + local.get $program + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/spi/StandardProgram#set:memory (param $this i32) (param $memory i32) + local.get $this + local.get $memory + i32.store offset=20 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/spi/StandardProgram#set:registers (param $this i32) (param $registers i32) + local.get $this + local.get $registers + i32.store offset=24 + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/spi/StandardProgram#set:metadata (param $this i32) (param $metadata i32) + local.get $this + local.get $metadata + i32.store + local.get $this + local.get $metadata + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/spi/StandardProgram#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store offset=4 + ) + (func $assembly/spi/StandardProgram#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=8 + ) + (func $assembly/spi/StandardProgram#get:program (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/program/Program#get:code (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/spi/StandardProgram#get:memory (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $assembly/spi/StandardProgram#get:registers (param $this i32) (result i32) + local.get $this + i32.load offset=24 + ) + (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i64) (result i32) + (local $sign i32) + (local $dest i32) + (local $decimals i32) + (local $val32 i32) + (local $buffer|6 i32) + (local $num i32) + (local $offset i32) + (local $val64 i64) + (local $buffer|10 i32) + (local $num|11 i64) + (local $offset|12 i32) + i32.const 0 + local.set $sign + i32.const 0 + drop + local.get $buffer + local.get $sign + i32.const 1 + i32.shl + i32.add + local.set $dest + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 0 + drop + local.get $value + i64.const 10 + i64.lt_u + if + local.get $buffer + local.get $value + i32.const 48 + i64.extend_i32_s + i64.or + i64.store16 + i32.const 1 + return + end + i32.const 0 + local.set $decimals + i32.const 8 + i32.const 4 + i32.le_u + drop + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + local.get $dest + local.set $buffer|6 + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|6 + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + local.set $val64 + local.get $val64 + call $~lib/util/number/decimalCount64High + local.set $decimals + local.get $dest + local.set $buffer|10 + local.get $val64 + local.set $num|11 + local.get $decimals + local.set $offset|12 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|10 + local.get $num|11 + local.get $offset|12 + call $~lib/util/number/utoa64_dec_lut + end + local.get $sign + local.get $decimals + i32.add + return + ) + (func $start:assembly/test-run + call $start:assembly/instructions/bit.test + call $start:assembly/instructions/branch.test + call $start:assembly/instructions/logic.test + call $start:assembly/instructions/math.test + call $start:assembly/instructions/rot.test + call $start:assembly/memory.test + call $start:assembly/program.test + call $start:assembly/spi.test + ) + (func $assembly/test/Test#get:name (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/test/Test#get:ptr (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/test/Assert#get:isOkay (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $~lib/rt/__visit_globals (param $0 i32) + (local $1 i32) + i32.const 480 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 1296 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 9584 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 21616 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 8624 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 288 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 2928 + local.get $0 + call $~lib/rt/itcms/__visit + i32.const 3984 + local.get $0 + call $~lib/rt/itcms/__visit + global.get $assembly/instructions/bit.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/branch.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/logic.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/math.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/rot.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/program.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/spi.test/TESTS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/RELEVANT_ARGS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/REQUIRED_BYTES + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/arguments/DECODERS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/memory/EMPTY_PAGE + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions-exe/RUN + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/codec/MASKS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + global.get $assembly/instructions/INSTRUCTIONS + local.tee $1 + if + local.get $1 + local.get $0 + call $~lib/rt/itcms/__visit + end + ) + (func $~lib/arraybuffer/ArrayBufferView~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/object/Object~visit (param $0 i32) (param $1 i32) + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/typedarray/Uint8Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit + ) + (func $assembly/memory-page/Page~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory-page/RawPage~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/Memory~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory-page/Arena~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $"~lib/map/Map~visit" (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $"~lib/map/Map#__visit" + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit + ) + (func $assembly/test/Test~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/test/Assert~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array<~lib/string/String>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<~lib/string/String>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/memory/MemoryBuilder~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + i32.const 1 + drop + local.get $this + local.set $cur + local.get $cur + local.get $this + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray<~lib/string/String>#__visit + ) + (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#__visit + ) + (func $assembly/memory/Result~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/ChunkBytes~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/Chunks~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/memory/PageData~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/typedarray/Uint8ClampedArray~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/function/Function<%28u8%29=>u8>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28u8%29=>u8>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28u8%29=>u8>#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/program/Mask~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $assembly/program/Program~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=8 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/JumpTable~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/program/BasicBlocks~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/codec/Decoder~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $assembly/spi/StandardProgram~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=16 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=20 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=24 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/rt/__visit_members (param $0 i32) (param $1 i32) + block $invalid + block $assembly/spi/StandardProgram + block $assembly/codec/ValOffset + block $assembly/codec/Decoder + block $~lib/staticarray/StaticArray + block $assembly/program/BasicBlocks + block $assembly/program/JumpTable + block $assembly/program/Program + block $~lib/array/Array + block $~lib/array/Array + block $~lib/staticarray/StaticArray + block $assembly/program/Mask + block $~lib/array/Array + block $~lib/function/Function<%28u8%29=>u8> + block $~lib/array/Array + block $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> + block $~lib/typedarray/Uint8ClampedArray + block $assembly/memory/PageData + block $assembly/memory/Chunks + block $~lib/staticarray/StaticArray + block $assembly/memory/ChunkBytes + block $assembly/memory/Result + block $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert> + block $~lib/staticarray/StaticArray<~lib/string/String> + block $assembly/memory/MemoryBuilder + block $~lib/array/Array + block $~lib/array/Array<~lib/string/String> + block $assembly/test/Assert + block $assembly/test/Test + block $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> + block $assembly/instructions/outcome/OutcomeData + block $"~lib/map/Map" + block $~lib/array/Array + block $assembly/memory-page/Arena + block $assembly/memory/Memory + block $~lib/staticarray/StaticArray + block $assembly/memory-page/RawPage + block $assembly/memory-page/Page + block $assembly/memory/MaybePageFault + block $assembly/arguments/Nibbles + block $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> + block $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> + block $assembly/arguments/Args + block $~lib/typedarray/Uint8Array + block $~lib/array/Array + block $~lib/arraybuffer/ArrayBufferView + block $~lib/string/String + block $~lib/arraybuffer/ArrayBuffer + block $~lib/object/Object + local.get $0 + i32.const 8 + i32.sub + i32.load + br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $~lib/arraybuffer/ArrayBufferView $~lib/array/Array $~lib/typedarray/Uint8Array $assembly/arguments/Args $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $assembly/arguments/Nibbles $assembly/memory/MaybePageFault $assembly/memory-page/Page $assembly/memory-page/RawPage $~lib/staticarray/StaticArray $assembly/memory/Memory $assembly/memory-page/Arena $~lib/array/Array $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $assembly/test/Test $assembly/test/Assert $~lib/array/Array<~lib/string/String> $~lib/array/Array $assembly/memory/MemoryBuilder $~lib/staticarray/StaticArray<~lib/string/String> $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert> $assembly/memory/Result $assembly/memory/ChunkBytes $~lib/staticarray/StaticArray $assembly/memory/Chunks $assembly/memory/PageData $~lib/typedarray/Uint8ClampedArray $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $~lib/array/Array $~lib/function/Function<%28u8%29=>u8> $~lib/array/Array $assembly/program/Mask $~lib/staticarray/StaticArray $~lib/array/Array $~lib/array/Array $assembly/program/Program $assembly/program/JumpTable $assembly/program/BasicBlocks $~lib/staticarray/StaticArray $assembly/codec/Decoder $assembly/codec/ValOffset $assembly/spi/StandardProgram $invalid + end + return + end + return + end + return + end + local.get $0 + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/typedarray/Uint8Array~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit + return + end + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/Page~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/RawPage~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory/Memory~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory-page/Arena~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $"~lib/map/Map~visit" + return + end + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit + return + end + local.get $0 + local.get $1 + call $assembly/test/Test~visit + return + end + local.get $0 + local.get $1 + call $assembly/test/Assert~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<~lib/string/String>~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/MemoryBuilder~visit + return + end + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray<~lib/string/String>~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/Result~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/ChunkBytes~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/memory/Chunks~visit + return + end + local.get $0 + local.get $1 + call $assembly/memory/PageData~visit + return + end + local.get $0 + local.get $1 + call $~lib/typedarray/Uint8ClampedArray~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/function/Function<%28u8%29=>u8>~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/Mask~visit + return + end + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $~lib/array/Array~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/Program~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/JumpTable~visit + return + end + local.get $0 + local.get $1 + call $assembly/program/BasicBlocks~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/codec/Decoder~visit + return + end + return + end + local.get $0 + local.get $1 + call $assembly/spi/StandardProgram~visit + return + end + unreachable + ) + (func $~start + call $start:assembly/test-run + ) + (func $~stack_check + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__data_end + i32.lt_s + if + i32.const 60848 + i32.const 60896 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + ) + (func $assembly/arguments/Args#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 6 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:b + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:c + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#set:d + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/arguments/Args.from (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32) + (local $x i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $x + i32.store + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $a + call $assembly/arguments/Args#set:a + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $b + call $assembly/arguments/Args#set:b + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $c + call $assembly/arguments/Args#set:c + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $d + call $assembly/arguments/Args#set:d + local.get $x + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/typedarray/Uint8Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/typedarray/Uint8Array#subarray (param $this i32) (param $begin i32) (param $end i32) (result i32) + (local $array i32) + (local $begin|4 i32) + (local $end|5 i32) + (local $len i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + (local $out i32) + (local $buf i32) + (local $19 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + block $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $array + i32.store + local.get $begin + local.set $begin|4 + local.get $end + local.set $end|5 + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + local.get $begin|4 + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $begin|4 + i32.add + local.tee $7 + i32.const 0 + local.tee $8 + local.get $7 + local.get $8 + i32.gt_s + select + else + local.get $begin|4 + local.tee $9 + local.get $len + local.tee $10 + local.get $9 + local.get $10 + i32.lt_s + select + end + local.set $begin|4 + local.get $end|5 + i32.const 0 + i32.lt_s + if (result i32) + local.get $len + local.get $end|5 + i32.add + local.tee $11 + i32.const 0 + local.tee $12 + local.get $11 + local.get $12 + i32.gt_s + select + else + local.get $end|5 + local.tee $13 + local.get $len + local.tee $14 + local.get $13 + local.get $14 + i32.lt_s + select + end + local.set $end|5 + local.get $end|5 + local.tee $15 + local.get $begin|4 + local.tee $16 + local.get $15 + local.get $16 + i32.gt_s + select + local.set $end|5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=8 + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $buf + local.get $out + local.get $buf + i32.store + local.get $out + local.get $buf + i32.const 0 + call $~lib/rt/itcms/__link + local.get $out + local.get $array + local.set $19 + global.get $~lib/memory/__stack_pointer + local.get $19 + i32.store offset=4 + local.get $19 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $begin|4 + i32.const 0 + i32.shl + i32.add + i32.store offset=4 + local.get $out + local.get $end|5 + local.get $begin|4 + i32.sub + i32.const 0 + i32.shl + i32.store offset=8 + local.get $out + br $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" + end + local.set $19 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $19 + return + ) + (func $~lib/typedarray/Uint8Array#__get (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + i32.ge_u + if + i32.const 480 + i32.const 720 + i32.const 167 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $index + i32.add + i32.load8_u + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/arguments/decodeI32 (param $input i32) (param $start i32) (param $end i32) (result i32) + (local $data i32) + (local $value1 f64) + (local $value2 f64) + (local $len i32) + (local $num i32) + (local $i i32) + (local $msb i32) + (local $prefix i32) + (local $i|11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $input + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $start + local.get $end + local.get $start + i32.gt_u + if (result i32) + local.get $end + else + local.get $start + end + call $~lib/typedarray/Uint8Array#subarray + local.tee $data + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.0 (result f64) + f64.const 4 + local.set $value1 + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.0 + end + i32.trunc_sat_f64_u + local.set $len + i32.const 0 + local.set $num + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_u + if + local.get $num + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.get $i + i32.const 8 + i32.mul + i32.shl + i32.or + local.set $num + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $len + i32.const 0 + i32.gt_u + if (result i32) + local.get $data + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $len + i32.const 1 + i32.sub + call $~lib/typedarray/Uint8Array#__get + i32.const 128 + i32.and + else + i32.const 0 + end + local.set $msb + local.get $msb + i32.const 0 + i32.gt_u + if (result i32) + i32.const 255 + else + i32.const 0 + end + local.set $prefix + local.get $len + local.set $i|11 + loop $for-loop|1 + local.get $i|11 + i32.const 4 + i32.lt_u + if + local.get $num + local.get $prefix + local.get $i|11 + i32.const 8 + i32.mul + i32.shl + i32.or + local.set $num + local.get $i|11 + i32.const 1 + i32.add + local.set $i|11 + br $for-loop|1 + end + end + local.get $num + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $start:assembly/arguments~anonymous|1 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/arguments/Nibbles#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 2 + i32.const 9 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Nibbles#set:low + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Nibbles#set:hig + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/arguments/nibbles (param $byte i32) (result i32) + (local $low i32) + (local $hig i32) + (local $n i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $byte + i32.const 15 + i32.and + local.set $low + local.get $byte + i32.const 255 + i32.and + i32.const 4 + i32.const 7 + i32.and + i32.shr_u + local.set $hig + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Nibbles#constructor + local.tee $n + i32.store + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $low + call $assembly/arguments/Nibbles#set:low + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $hig + call $assembly/arguments/Nibbles#set:hig + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/arguments/twoImm (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $first i32) + (local $second i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.1 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.1 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $first + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $second + local.get $first + local.get $second + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|2 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $lim + call $assembly/arguments/twoImm + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $start:assembly/arguments~anonymous|3 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/arguments~anonymous|4 (param $data i32) (param $lim i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/typedarray/Uint8Array#subarray@varargs (param $this i32) (param $begin i32) (param $end i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $begin + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $begin + local.get $end + call $~lib/typedarray/Uint8Array#subarray + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/arguments/decodeU32 (param $data i32) (result i32) + (local $num i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 2 + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $num + local.get $num + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 3 + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + local.set $num + local.get $num + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/arguments~anonymous|5 (param $data i32) (param $_lim i32) (result i32) + (local $a i32) + (local $b i32) + (local $c i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Nibbles#get:low + local.set $a + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/decodeU32 + local.set $b + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 5 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/decodeU32 + local.set $c + local.get $a + i32.const 255 + i32.and + local.get $b + local.get $c + i32.const 0 + call $assembly/arguments/Args.from + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/arguments~anonymous|6 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $immA i32) + (local $immB i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.2 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.2 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $immA + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $immB + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $immA + local.get $immB + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|7 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $value1 f64) + (local $value2 f64) + (local $split i32) + (local $immA i32) + (local $offs i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + block $~lib/math/NativeMath.min|inlined.3 (result f64) + f64.const 4 + local.set $value1 + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + f64.convert_i32_u + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.3 + end + i32.trunc_sat_f64_s + i32.const 1 + i32.add + local.set $split + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $split + call $assembly/arguments/decodeI32 + local.set $immA + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $split + local.get $lim + call $assembly/arguments/decodeI32 + local.set $offs + local.get $n + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $immA + local.get $offs + i32.const 0 + call $assembly/arguments/Args.from + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/arguments~anonymous|8 (param $data i32) (param $_lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + i32.const 0 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|9 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|10 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 1 + local.get $lim + call $assembly/arguments/decodeI32 + i32.const 0 + call $assembly/arguments/Args.from + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/arguments~anonymous|11 (param $data i32) (param $lim i32) (result i32) + (local $n i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + i32.const 1 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $lim + i32.const 1 + i32.gt_u + if (result i32) + local.get $lim + i32.const 1 + i32.sub + else + i32.const 0 + end + call $assembly/arguments/twoImm + local.tee $result + i32.store offset=12 + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $n + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:a + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/arguments/Args.from + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/arguments~anonymous|12 (param $data i32) (param $_lim i32) (result i32) + (local $a i32) + (local $b i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $a + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $b + i32.store offset=8 + local.get $a + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:hig + i32.const 255 + i32.and + local.get $a + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + local.get $b + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Nibbles#get:low + i32.const 255 + i32.and + i32.const 0 + call $assembly/arguments/Args.from + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/MaybePageFault#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 10 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:isFault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:isAccess + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#set:fault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/arraybuffer/ArrayBufferView#constructor (param $this i32) (param $length i32) (param $alignLog2 i32) (result i32) + (local $buffer i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 3 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:buffer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#set:byteLength + local.get $length + i32.const 1073741820 + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1344 + i32.const 19 + i32.const 57 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $length + local.get $alignLog2 + i32.shl + local.tee $length + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $buffer + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $~lib/arraybuffer/ArrayBufferView#set:buffer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $buffer + call $~lib/arraybuffer/ArrayBufferView#set:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $length + call $~lib/arraybuffer/ArrayBufferView#set:byteLength + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $length + i32.const 0 + call $~lib/arraybuffer/ArrayBufferView#constructor + local.tee $this + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/memory-page/Page#constructor (param $this i32) (param $access i32) (param $raw i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 11 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $access + call $assembly/memory-page/Page#set:access + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $raw + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory-page/Page#set:raw + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory-page/RawPage#constructor (param $this i32) (param $id i32) (param $page i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 12 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $id + call $assembly/memory-page/RawPage#set:id + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $page + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory-page/RawPage#set:page + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $start:assembly/memory + (local $0 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + call $start:assembly/memory-page + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + global.set $assembly/memory/NO_PAGE_FAULT + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + global.set $assembly/memory/EMPTY_UINT8ARRAY + i32.const 0 + global.get $assembly/memory-page/Access.None + i32.const 0 + i32.const -1 + i32.const 0 + call $assembly/memory-page/RawPage#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/memory-page/Page#constructor + global.set $assembly/memory/EMPTY_PAGE + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i64) + (local $value i64) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/OutcomeData#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.const 18 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/instructions/outcome/Outcome.Ok + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:staticJump + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:dJump + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/instructions/outcome/Result.PANIC + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#set:exitCode + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $start:assembly/instructions/bit~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.popcnt + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.popcnt + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.clz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.clz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ctz + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.ctz + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u8SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u16SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|8 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.const 65535 + i32.and + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/bit~anonymous|9 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/polyfills/bswap + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $"~lib/map/Map#constructor" (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.const 17 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 4 + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + i32.const 1 + i32.sub + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 4 + block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.0" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesOffset" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/typedarray/Uint8Array.wrap (param $buffer i32) (param $byteOffset i32) (param $length i32) (result i32) + (local $buffer|3 i32) + (local $byteOffset|4 i32) + (local $len i32) + (local $byteLength i32) + (local $bufferByteLength i32) + (local $out i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + block $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) + global.get $~lib/memory/__stack_pointer + local.get $buffer + local.tee $buffer|3 + i32.store + local.get $byteOffset + local.set $byteOffset|4 + local.get $length + local.set $len + local.get $buffer|3 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/arraybuffer/ArrayBuffer#get:byteLength + local.set $bufferByteLength + local.get $byteOffset|4 + local.get $bufferByteLength + i32.gt_u + local.get $byteOffset|4 + i32.const 0 + i32.and + i32.or + if + i32.const 480 + i32.const 720 + i32.const 1860 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $len + i32.const 0 + i32.lt_s + if + local.get $len + i32.const -1 + i32.eq + if + local.get $bufferByteLength + i32.const 0 + i32.and + if + i32.const 1296 + i32.const 720 + i32.const 1865 + i32.const 9 + call $~lib/builtins/abort + unreachable + end + local.get $bufferByteLength + local.get $byteOffset|4 + i32.sub + local.set $byteLength + else + i32.const 1296 + i32.const 720 + i32.const 1869 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + else + local.get $len + i32.const 0 + i32.shl + local.set $byteLength + local.get $byteOffset|4 + local.get $byteLength + i32.add + local.get $bufferByteLength + i32.gt_s + if + i32.const 1296 + i32.const 720 + i32.const 1874 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 5 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=8 + local.get $out + local.get $buffer|3 + i32.store + local.get $out + local.get $buffer|3 + i32.const 0 + call $~lib/rt/itcms/__link + local.get $out + local.get $byteLength + i32.store offset=8 + local.get $out + local.get $buffer|3 + local.get $byteOffset|4 + i32.add + i32.store offset=4 + local.get $out + br $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" + end + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $~lib/array/ensureCapacity (param $array i32) (param $newSize i32) (param $alignLog2 i32) (param $canGrow i32) + (local $oldCapacity i32) + (local $oldData i32) + (local $6 i32) + (local $7 i32) + (local $newCapacity i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $newData i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $array + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + local.set $oldCapacity + local.get $newSize + local.get $oldCapacity + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + local.get $newSize + i32.const 1073741820 + local.get $alignLog2 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1888 + i32.const 19 + i32.const 48 + call $~lib/builtins/abort + unreachable + end + local.get $array + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $oldData + local.get $newSize + local.tee $6 + i32.const 8 + local.tee $7 + local.get $6 + local.get $7 + i32.gt_u + select + local.get $alignLog2 + i32.shl + local.set $newCapacity + local.get $canGrow + if + local.get $oldCapacity + i32.const 1 + i32.shl + local.tee $9 + i32.const 1073741820 + local.tee $10 + local.get $9 + local.get $10 + i32.lt_u + select + local.tee $11 + local.get $newCapacity + local.tee $12 + local.get $11 + local.get $12 + i32.gt_u + select + local.set $newCapacity + end + local.get $oldData + local.get $newCapacity + call $~lib/rt/itcms/__renew + local.set $newData + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $newData + local.get $oldData + i32.ne + if + local.get $array + local.get $newData + i32.store + local.get $array + local.get $newData + i32.store offset=4 + local.get $array + local.get $newData + i32.const 0 + call $~lib/rt/itcms/__link + end + local.get $array + local.get $newCapacity + i32.store offset=8 + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#unshift (param $this i32) (param $value i32) (result i32) + (local $len i32) + (local $ptr i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.set $ptr + local.get $ptr + i32.const 4 + i32.add + local.get $ptr + local.get $len + i32.const 1 + i32.sub + i32.const 2 + i32.shl + memory.copy + local.get $ptr + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory-page/Arena#constructor (param $this i32) (param $pageCount i32) (result i32) + (local $2 i32) + (local $data i32) + (local $i i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 15 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:free + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:arenaBytes + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory-page/Arena#set:extraPageIndex + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/memory-page/PAGE_SIZE + local.get $pageCount + i32.mul + call $assembly/memory-page/Arena#set:arenaBytes + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + i32.const 2 + i32.const 16 + i32.const 1856 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory-page/Arena#set:free + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pageCount + call $assembly/memory-page/Arena#set:extraPageIndex + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory-page/Arena#get:arenaBytes + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $data + i32.store offset=12 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pageCount + i32.lt_s + if + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory-page/Arena#get:free + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + local.get $i + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array.wrap + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory-page/RawPage#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/array/Array#unshift + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/memory/MemoryBuilder#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 24 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $"~lib/map/Map#constructor" + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/MemoryBuilder#set:pages + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 128 + call $assembly/memory-page/Arena#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/MemoryBuilder#set:arena + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $"~lib/map/Map#find" (param $this i32) (param $key i32) (param $hashCode i32) (result i32) + (local $entry i32) + (local $taggedNext i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + i32.load + local.set $entry + loop $while-continue|0 + local.get $entry + if + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + local.set $taggedNext + local.get $taggedNext + i32.const 1 + i32.and + i32.eqz + if (result i32) + local.get $entry + call $"~lib/map/MapEntry#get:key" + local.get $key + i32.eq + else + i32.const 0 + end + if + local.get $entry + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $taggedNext + i32.const 1 + i32.const -1 + i32.xor + i32.and + local.set $entry + br $while-continue|0 + end + end + i32.const 0 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $"~lib/map/Map#has" (param $this i32) (param $key i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $key + local.get $key + call $~lib/util/hash/HASH + call $"~lib/map/Map#find" + i32.const 0 + i32.ne + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/Memory#constructor (param $this i32) (param $arena i32) (param $pages i32) (param $sbrkAddress i32) (result i32) + (local $sbrkPage i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 14 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $arena + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory/Memory#set:arena + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/memory/Memory#set:pages + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $sbrkAddress + call $assembly/memory/Memory#set:sbrkAddress + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $sbrkAddress + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $sbrkPage + local.get $sbrkPage + global.get $assembly/memory-page/RESERVED_PAGES + i32.lt_u + if + i32.const 1936 + i32.const 2048 + i32.const 119 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $sbrkPage + call $"~lib/map/Map#has" + if (result i32) + local.get $sbrkPage + else + local.get $sbrkPage + i32.const 1 + i32.sub + end + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/memory/MemoryBuilder#build (param $this i32) (param $sbrkAddress i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + i32.const 0 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MemoryBuilder#get:arena + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MemoryBuilder#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $sbrkAddress + call $assembly/memory/Memory#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/MemoryBuilder#build@varargs (param $this i32) (param $sbrkAddress i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + global.get $assembly/memory-page/RESERVED_MEMORY + local.set $sbrkAddress + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $sbrkAddress + call $assembly/memory/MemoryBuilder#build + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/test/Assert#constructor (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 21 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 1 + call $assembly/test/Assert#set:isOkay + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 2 + i32.const 22 + i32.const 2112 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/test/Assert#set:errors + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/util/string/joinStringArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $4 i32) + (local $estLen i32) + (local $value i32) + (local $i i32) + (local $offset i32) + (local $sepLen i32) + (local $result i32) + (local $i|11 i32) + (local $valueLen i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + end + local.get $lastIndex + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + i32.load + local.tee $4 + i32.store + local.get $4 + if (result i32) + local.get $4 + else + i32.const 4080 + end + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + end + i32.const 0 + local.set $estLen + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $i + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $estLen + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + i32.add + local.set $estLen + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $offset + local.get $separator + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + local.set $sepLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + local.get $sepLen + local.get $lastIndex + i32.mul + i32.add + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=12 + i32.const 0 + local.set $i|11 + loop $for-loop|1 + local.get $i|11 + local.get $lastIndex + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $i|11 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + local.set $valueLen + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value + local.get $valueLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $valueLen + i32.add + local.set $offset + end + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i|11 + i32.const 1 + i32.add + local.set $i|11 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $dataStart + local.get $lastIndex + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + local.get $value + i32.const 0 + i32.ne + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value + local.get $value + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + local.get $13 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + memory.copy + end + local.get $result + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + i32.const 1 + i32.lt_s + drop + i32.const 1 + drop + local.get $this + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/staticarray/StaticArray<~lib/string/String>#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/util/string/joinStringArray + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/array/Array<~lib/string/String>#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array<~lib/string/String>#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 1 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array<~lib/string/String>#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) + (local $4 i32) + (local $5 i32) + (local $actualDisplay i32) + (local $7 i32) + (local $8 i32) + (local $expectDisplay i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $actual + local.get $expected + i32.ne + if + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 10 + call $~lib/number/I32#toString + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 16 + call $~lib/number/I32#toString + local.tee $5 + i32.store offset=8 + i32.const 2256 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $4 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 2256 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $5 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 2256 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $actualDisplay + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 10 + call $~lib/number/I32#toString + local.tee $7 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 16 + call $~lib/number/I32#toString + local.tee $8 + i32.store offset=24 + i32.const 4112 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $7 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4112 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $8 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4112 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $expectDisplay + i32.store offset=28 + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + call $assembly/test/Assert#get:errors + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $10 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $12 + i32.store offset=44 + i32.const 4272 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 1 + local.get $10 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4272 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 3 + local.get $11 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4272 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 5 + local.get $12 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4272 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i64) (param $expected i64) (param $msg i32) + (local $4 i32) + (local $5 i32) + (local $actualDisplay i32) + (local $7 i32) + (local $8 i32) + (local $expectDisplay i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $actual + local.get $expected + i64.ne + if + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 10 + call $~lib/number/U64#toString + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 16 + call $~lib/number/U64#toString + local.tee $5 + i32.store offset=8 + i32.const 4320 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $4 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4320 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $5 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4320 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $actualDisplay + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 10 + call $~lib/number/U64#toString + local.tee $7 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 16 + call $~lib/number/U64#toString + local.tee $8 + i32.store offset=24 + i32.const 4368 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $7 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4368 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $8 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4368 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $expectDisplay + i32.store offset=28 + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + call $assembly/test/Assert#get:errors + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $10 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $12 + i32.store offset=44 + i32.const 4416 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 1 + local.get $10 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4416 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 3 + local.get $11 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4416 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 5 + local.get $12 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 4416 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit.test~anonymous|0 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281470681747729 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/count_set_bits_64 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 2 + i64.const 8 + i64.mul + i64.const 4 + i64.add + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/test/Test#constructor (param $this i32) (param $name i32) (param $ptr i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 20 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $name + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/test/Test#set:name + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $ptr + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/test/Test#set:ptr + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/test/test (param $name i32) (param $ptr i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 0 + local.get $name + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $ptr + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/test/Test#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|1 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281470681747729 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/count_set_bits_32 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 4 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|2 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281406257234193 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/leading_zero_bits_64 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 16 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|3 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281470681747729 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/leading_zero_bits_32 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 19 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|4 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281406257233920 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/trailing_zero_bits_64 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 36 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|5 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281406257233920 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/trailing_zero_bits_32 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 32 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|6 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/sign_extend_8 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -17 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|7 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/sign_extend_16 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -16657 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/bit.test~anonymous|8 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/zero_extend_16 + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 48879 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i64) (param $expected i64) (param $msg i32) + (local $4 i32) + (local $5 i32) + (local $actualDisplay i32) + (local $7 i32) + (local $8 i32) + (local $expectDisplay i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $actual + local.get $expected + i64.ne + if + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 10 + call $~lib/number/I64#toString + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 16 + call $~lib/number/I64#toString + local.tee $5 + i32.store offset=8 + i32.const 5264 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $4 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5264 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $5 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5264 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $actualDisplay + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 10 + call $~lib/number/I64#toString + local.tee $7 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 16 + call $~lib/number/I64#toString + local.tee $8 + i32.store offset=24 + i32.const 5312 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $7 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5312 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $8 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5312 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $expectDisplay + i32.store offset=28 + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + call $assembly/test/Assert#get:errors + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $10 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $12 + i32.store offset=44 + i32.const 5360 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 1 + local.get $10 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5360 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 3 + local.get $11 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5360 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 5 + local.get $12 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 5360 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit.test~anonymous|9 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $res i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 15 + call $assembly/arguments/Args#set:b + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 281409993162479 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/bit/reverse_bytes + i32.load + call_indirect (type $1) + local.tee $res + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i64.const 15 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1171307680032161792 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 1888 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/bit.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + call $start:assembly/arguments + call $start:assembly/memory + global.get $~lib/memory/__stack_pointer + i32.const 10 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 1792 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4464 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 4496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4560 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 4592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4656 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + i32.const 4688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4752 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + i32.const 4784 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4848 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 5 + i32.const 4880 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4944 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 6 + i32.const 4976 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 5024 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 7 + i32.const 5056 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 5104 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 8 + i32.const 5136 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 5184 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 9 + i32.const 5216 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 5408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/bit.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/instructions/outcome/staticJump (param $offset i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.StaticJump + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $offset + call $assembly/instructions/outcome/OutcomeData#set:staticJump + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/branch~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.eq + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.ne + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.lt_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.le_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.ge_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $b + i64.gt_u + if + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/branch~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.lt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.le_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.ge_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.gt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.eq + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ne + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_u + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ge_u + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/branch~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.ge_s + if + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) + (local $4 i32) + (local $5 i32) + (local $actualDisplay i32) + (local $7 i32) + (local $8 i32) + (local $expectDisplay i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $actual + local.get $expected + i32.ne + if + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 10 + call $~lib/number/U32#toString + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 16 + call $~lib/number/U32#toString + local.tee $5 + i32.store offset=8 + i32.const 6048 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $4 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6048 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $5 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6048 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $actualDisplay + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 10 + call $~lib/number/U32#toString + local.tee $7 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 16 + call $~lib/number/U32#toString + local.tee $8 + i32.store offset=24 + i32.const 6096 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $7 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6096 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $8 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6096 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $expectDisplay + i32.store offset=28 + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + call $assembly/test/Assert#get:errors + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $10 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $12 + i32.store offset=44 + i32.const 6144 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 1 + local.get $10 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6144 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 3 + local.get $11 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6144 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 5 + local.get $12 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 6144 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/branch.test~anonymous|0 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 254 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const -559038737 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 254 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/branch/branch_eq_imm + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.StaticJump + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:staticJump + i32.const -559038737 + i32.const 6000 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/branch.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 1 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 5952 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 6192 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/branch.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/logic~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.and + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1 + i64.xor + i64.or + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.xor + i64.const -1 + i64.xor + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/logic.test~anonymous|0 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 3 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 15 + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 263882790666241 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/logic/and_inv + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 263882790666240 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/logic.test~anonymous|1 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 3 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 15 + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 263882790666241 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/logic/or_inv + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -15 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/logic.test~anonymous|2 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 3 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 15 + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 263882790666240 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/logic/xnor + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -263882790666256 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/logic.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 3 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 6512 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 6560 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 6592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 6624 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 6656 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 6688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/logic.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/math~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $c i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $c + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $c + i64.add + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.mul + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.const 4294967296 + i64.or + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $sum i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + local.set $sum + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $sum + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/math~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i32.add + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 2 + i64.const 32 + call $~lib/math/ipow64 + i64.add + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + i64.sub + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.mul + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i32.div_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i32.MIN_VALUE + i64.extend_i32_s + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i32) + (local $b i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i32.rem_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i32) + (local $a i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $a + local.get $a + i32.const 0 + i32.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i32.const -1 + i32.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i32.MIN_VALUE + i32.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + i64.extend_i32_s + local.get $a + i64.extend_i32_s + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.sub + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.mul + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.div_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + global.get $~lib/builtins/u64.MAX_VALUE + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i64.MIN_VALUE + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.div_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|18 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.rem_u + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|19 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $b i64) + (local $a i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $a + i64.const 0 + i64.eq + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + call $~lib/staticarray/StaticArray#__set + else + local.get $a + i64.const -1 + i64.eq + if (result i32) + local.get $b + global.get $~lib/builtins/i64.MIN_VALUE + i64.eq + else + i32.const 0 + end + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + call $~lib/staticarray/StaticArray#__set + else + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $b + local.get $a + i64.rem_s + call $~lib/staticarray/StaticArray#__set + end + end + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|20 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperSigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|21 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperUnsigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|22 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/mulUpperSignedUnsigned + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/math~anonymous|23 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.lt_s + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|24 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.lt_u + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|25 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.gt_s + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math~anonymous|26 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $a i64) + (local $b i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $a + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $b + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $a + local.get $b + i64.gt_u + if (result i64) + local.get $b + else + local.get $a + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/math.test~anonymous|0 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 3 + i32.const 0 + call $assembly/arguments/Args.from + local.tee $args + i32.store + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=4 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/math/max + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 2 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/math.test~anonymous|1 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 3 + i32.const 0 + call $assembly/arguments/Args.from + local.tee $args + i32.store + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=4 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/math/max_u + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/math.test~anonymous|2 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 3 + i32.const 0 + call $assembly/arguments/Args.from + local.tee $args + i32.store + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=4 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/math/min + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/math.test~anonymous|3 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 3 + i32.const 0 + call $assembly/arguments/Args.from + local.tee $args + i32.store + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=4 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 0 + i64.const 2 + i64.const 63 + call $~lib/math/ipow64 + i64.sub + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/math/min_u + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 2 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/math.test~anonymous|4 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 1 + i32.const 3 + i32.const 0 + call $assembly/arguments/Args.from + local.tee $args + i32.store + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=4 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + i64.const 64 + call $~lib/math/ipow64 + i64.const 1 + i64.sub + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 2 + i64.const 64 + call $~lib/math/ipow64 + i64.const 1 + i64.sub + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/math/add_32 + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -2 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/math.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 5 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 7584 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 7616 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 7648 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 7680 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 7712 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 7744 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + i32.const 7776 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 7808 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + i32.const 7840 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 7872 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/math.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/rot~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_l + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_l_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot.test~anonymous|0 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 8 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/rot/rot_r_64_imm + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1224979098630181442 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/rot.test~anonymous|1 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const -559038737 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 8 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/rot/rot_r_64_imm_alt + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1152921504609030722 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/rot.test~anonymous|2 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 8 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 8 + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/rot/rot_l_64 + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 956397711104 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/rot.test~anonymous|3 (param $$0 i32) (result i32) + (local $args i32) + (local $regs i32) + (local $memo i32) + (local $ret i32) + (local $assert i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/arguments/Args#constructor + local.tee $args + i32.store + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $assembly/arguments/Args#set:a + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 1 + call $assembly/arguments/Args#set:b + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 8 + call $assembly/arguments/Args#set:c + global.get $~lib/memory/__stack_pointer + call $assembly/registers/newRegisters + local.tee $regs + i32.store offset=8 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 8 + call $~lib/staticarray/StaticArray#__set + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + i64.const 3735928559 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $memo + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $memo + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + i32.const 3 + global.set $~argumentsLength + global.get $assembly/instructions/rot/rot_l_32 + i32.load + call_indirect (type $1) + local.tee $ret + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=28 + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $ret + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/instructions/outcome/OutcomeData#get:outcome + global.get $assembly/instructions/outcome/Outcome.Ok + i32.const 2144 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $regs + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + local.get $args + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=32 + local.get $6 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const -1379995682 + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $start:assembly/instructions/rot.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 8160 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 8208 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 8240 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 8304 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 8336 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 8384 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + i32.const 8416 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 8464 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/rot.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Chunks#constructor (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 30 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:fault + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:first + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#set:second + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory/Chunks#constructor@varargs (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $first + i32.store + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_UINT8ARRAY + local.tee $second + i32.store offset=4 + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + local.get $first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + local.get $second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + local.get $4 + call $assembly/memory/Chunks#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory/PageData#constructor (param $this i32) (param $fault i32) (param $page i32) (param $relativeAddress i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 31 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/PageData#set:fault + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $page + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/PageData#set:page + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $relativeAddress + call $assembly/memory/PageData#set:relativeAddress + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory/fault (param $address i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isFault + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $address + call $assembly/memory/MaybePageFault#set:fault + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $"~lib/map/Map#get" (param $this i32) (param $key i32) (result i32) + (local $entry i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $key + local.get $key + call $~lib/util/hash/HASH + call $"~lib/map/Map#find" + local.set $entry + local.get $entry + i32.eqz + if + i32.const 8624 + i32.const 8688 + i32.const 105 + i32.const 17 + call $~lib/builtins/abort + unreachable + end + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory-page/Page#can (param $this i32) (param $access i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/Page#get:access + global.get $assembly/memory-page/Access.Write + i32.eq + if (result i32) + i32.const 1 + else + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/Page#get:access + local.get $access + i32.eq + end + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/Memory#getPage (param $this i32) (param $access i32) (param $address i32) (result i32) + (local $pageIdx i32) + (local $relAddress i32) + (local $pageStart i32) + (local $page i32) + (local $f i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $address + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $pageIdx + local.get $address + global.get $assembly/memory-page/PAGE_SIZE + i32.rem_u + local.set $relAddress + local.get $pageIdx + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + local.set $pageStart + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/memory/Memory#get:pages + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $pageIdx + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.get $pageStart + call $assembly/memory/fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory/EMPTY_PAGE + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/memory/Memory#get:pages + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $pageIdx + call $"~lib/map/Map#get" + local.tee $page + i32.store offset=8 + local.get $page + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $access + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $pageStart + call $assembly/memory/fault + local.tee $f + i32.store offset=12 + local.get $f + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isAccess + i32.const 0 + local.get $f + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory/EMPTY_PAGE + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $page + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $relAddress + call $assembly/memory/PageData#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/typedarray/Uint8Array#fill (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $value + local.get $start + local.get $end + call $~lib/util/bytes/FILL + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/typedarray/Uint8Array#fill@varargs (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $start + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $value + local.get $start + local.get $end + call $~lib/typedarray/Uint8Array#fill + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/memory-page/RawPage#get:data (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:page + i32.const 0 + i32.eq + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory-page/RawPage#set:page + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:page + local.tee $1 + i32.store offset=12 + local.get $1 + if (result i32) + local.get $1 + else + i32.const 8736 + i32.const 8864 + i32.const 46 + i32.const 12 + call $~lib/builtins/abort + unreachable + end + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/memory/Memory#getChunks (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) + (local $pageData i32) + (local $page i32) + (local $relativeAddress i32) + (local $endAddress i32) + (local $needSecondPage i32) + (local $first i32) + (local $secondPageIdx i32) + (local $secondPageStart i32) + (local $secondPage i32) + (local $f i32) + (local $firstChunk i32) + (local $secondChunk i32) + (local $16 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + local.get $bytes + i32.const 255 + i32.and + i32.const 0 + i32.eq + if + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $access + local.get $address + call $assembly/memory/Memory#getPage + local.tee $pageData + i32.store offset=4 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/PageData#get:fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/MaybePageFault#get:isFault + if + i32.const 0 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/PageData#get:fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/PageData#get:page + local.tee $page + i32.store offset=12 + local.get $pageData + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + call $assembly/memory/PageData#get:relativeAddress + local.set $relativeAddress + local.get $relativeAddress + local.get $bytes + i32.const 255 + i32.and + i32.add + local.set $endAddress + local.get $endAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.gt_u + local.set $needSecondPage + local.get $needSecondPage + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $page + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $relativeAddress + local.get $endAddress + call $~lib/typedarray/Uint8Array#subarray + local.tee $first + i32.store offset=20 + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $first + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + i32.const 2 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + local.get $address + local.get $bytes + i32.const 255 + i32.and + i32.add + i64.extend_i32_u + global.get $assembly/memory/MEMORY_SIZE + i64.rem_s + i32.wrap_i64 + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $secondPageIdx + local.get $secondPageIdx + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + local.set $secondPageStart + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/Memory#get:pages + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $secondPageIdx + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.get $secondPageStart + call $assembly/memory/fault + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory/Memory#get:pages + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $secondPageIdx + call $"~lib/map/Map#get" + local.tee $secondPage + i32.store offset=24 + local.get $secondPage + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $access + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $secondPageStart + call $assembly/memory/fault + local.tee $f + i32.store offset=28 + local.get $f + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isAccess + i32.const 0 + local.get $f + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/Chunks#constructor@varargs + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + end + global.get $~lib/memory/__stack_pointer + local.get $page + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $relativeAddress + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $firstChunk + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $secondPage + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory-page/Page#get:raw + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + call $assembly/memory-page/RawPage#get:data + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + i32.const 0 + local.get $relativeAddress + local.get $bytes + i32.const 255 + i32.and + i32.add + global.get $assembly/memory-page/PAGE_SIZE + i32.sub + call $~lib/typedarray/Uint8Array#subarray + local.tee $secondChunk + i32.store offset=36 + i32.const 0 + global.get $assembly/memory/NO_PAGE_FAULT + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store + local.get $16 + local.get $firstChunk + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=8 + local.get $16 + local.get $secondChunk + local.set $16 + global.get $~lib/memory/__stack_pointer + local.get $16 + i32.store offset=16 + local.get $16 + call $assembly/memory/Chunks#constructor + local.set $16 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $16 + return + ) + (func $assembly/memory/ChunkBytes#constructor (param $this i32) (param $fault i32) (param $bytes i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 28 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $fault + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory/ChunkBytes#set:fault + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $bytes + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/memory/ChunkBytes#set:bytes + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory/ChunkBytes#constructor@varargs (param $this i32) (param $fault i32) (param $bytes i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/staticarray/StaticArray#constructor + local.tee $bytes + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $fault + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $bytes + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/memory/ChunkBytes#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/getBytes (param $bytes i32) (param $first i32) (param $second i32) (result i32) + (local $res i32) + (local $len i32) + (local $i i32) + (local $i|6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $bytes + i32.const 255 + i32.and + call $~lib/staticarray/StaticArray#constructor + local.tee $res + i32.store + local.get $first + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $i + local.get $first + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|6 + loop $for-loop|1 + local.get $i|6 + local.get $second + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $len + local.get $i|6 + i32.add + local.get $second + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + local.get $i|6 + call $~lib/typedarray/Uint8Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $i|6 + i32.const 1 + i32.add + local.set $i|6 + br $for-loop|1 + end + end + local.get $res + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $assembly/memory/Memory#getBytes (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) + (local $res i32) + (local $data i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $access + local.get $address + local.get $bytes + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $assembly/memory/MaybePageFault#get:isFault + if + i32.const 0 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/ChunkBytes#constructor@varargs + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + global.get $~lib/memory/__stack_pointer + local.get $bytes + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:first + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:second + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/getBytes + local.tee $data + i32.store offset=16 + i32.const 0 + local.get $res + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/Chunks#get:fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $assembly/memory/ChunkBytes#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/memory/Result#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 27 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/memory/Result#set:ok + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/memory/MaybePageFault#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/memory/Result#set:fault + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/memory/Memory#getI8 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + call $assembly/instructions/utils/u8SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU64 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 8 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 8 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 16 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 24 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 4 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 32 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 5 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 40 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 6 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 48 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 7 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + i64.const 56 + i64.shl + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) + (local $4 i32) + (local $5 i32) + (local $actualDisplay i32) + (local $7 i32) + (local $8 i32) + (local $expectDisplay i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $actual + i32.const 0 + i32.ne + local.get $expected + i32.const 0 + i32.ne + i32.ne + if + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 0 + call $~lib/number/Bool#toString + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $actual + i32.const 16 + call $~lib/number/Bool#toString + local.tee $5 + i32.store offset=8 + i32.const 8992 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $4 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 8992 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $5 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 8992 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $actualDisplay + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 0 + call $~lib/number/Bool#toString + local.tee $7 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expected + i32.const 16 + call $~lib/number/Bool#toString + local.tee $8 + i32.store offset=24 + i32.const 9104 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 0 + local.get $7 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 9104 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 2 + local.get $8 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 9104 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.tee $expectDisplay + i32.store offset=28 + local.get $this + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + call $assembly/test/Assert#get:errors + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store + local.get $13 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $10 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $11 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $12 + i32.store offset=44 + i32.const 9152 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 1 + local.get $10 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 9152 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 3 + local.get $11 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 9152 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 5 + local.get $12 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 9152 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=32 + local.get $13 + i32.const 4080 + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=48 + local.get $13 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $13 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=12 + local.get $13 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/memory.test~anonymous|0 (param $$0 i32) (result i32) + (local $mem i32) + (local $a i32) + (local $b i32) + (local $assert i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $mem + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $assembly/memory/Memory#getI8 + local.tee $a + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + global.get $assembly/memory-page/RESERVED_MEMORY + i32.const 1 + i32.sub + call $assembly/memory/Memory#getU64 + local.tee $b + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=16 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $a + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 1 + i32.const 8944 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $a + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9200 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $a + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:fault + i32.const 0 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $b + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 1 + i32.const 9248 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $b + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9296 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $b + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/memory/MaybePageFault#get:fault + i32.const 61440 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/string/String#concat (param $this i32) (param $other i32) (result i32) + (local $thisSize i32) + (local $otherSize i32) + (local $outSize i32) + (local $out i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $thisSize + local.get $other + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $otherSize + local.get $thisSize + local.get $otherSize + i32.add + local.set $outSize + local.get $outSize + i32.const 0 + i32.eq + if + i32.const 4080 + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $out + local.get $this + local.get $thisSize + memory.copy + local.get $out + local.get $thisSize + i32.add + local.get $other + local.get $otherSize + memory.copy + local.get $out + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#pop (param $this i32) (result i32) + (local $len i32) + (local $val i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + local.set $len + local.get $len + i32.const 1 + i32.lt_s + if + i32.const 9584 + i32.const 1888 + i32.const 271 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $len + i32.const 1 + i32.sub + local.tee $len + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $val + i32.store offset=4 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $len + call $~lib/array/Array#set:length_ + local.get $val + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/console/console.log (param $message i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $message + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/bindings/dom/console.log + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory-page/Arena#acquire (param $this i32) (result i32) + (local $allocatedMemory i32) + (local $data i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:free + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + i32.const 0 + i32.gt_s + if + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:free + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#pop + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.set $allocatedMemory + local.get $allocatedMemory + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/Arena#get:arenaBytes + i32.eq + if + i32.const 9632 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/console/console.log + end + global.get $~lib/memory/__stack_pointer + local.get $allocatedMemory + global.get $assembly/memory-page/ALLOCATE_EAGERLY + i32.lt_u + if (result i32) + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + else + i32.const 0 + end + local.tee $data + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + i32.const 1 + i32.add + call $assembly/memory-page/Arena#set:extraPageIndex + i32.const 0 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#get:extraPageIndex + local.get $data + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/memory-page/RawPage#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) + (local $newBucketsCapacity i32) + (local $newBuckets i32) + (local $newEntriesCapacity i32) + (local $newEntries i32) + (local $oldPtr i32) + (local $oldEnd i32) + (local $newPtr i32) + (local $oldEntry i32) + (local $newEntry i32) + (local $oldEntryKey i32) + (local $newBucketIndex i32) + (local $newBucketPtrBase i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $newBucketsMask + i32.const 1 + i32.add + local.set $newBucketsCapacity + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $newBucketsCapacity + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newBuckets + i32.store + local.get $newBucketsCapacity + i32.const 8 + i32.mul + i32.const 3 + i32.div_s + local.set $newEntriesCapacity + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $newEntriesCapacity + block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.1" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newEntries + i32.store offset=4 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entries" + local.set $oldPtr + local.get $oldPtr + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.2" + end + i32.mul + i32.add + local.set $oldEnd + local.get $newEntries + local.set $newPtr + loop $while-continue|0 + local.get $oldPtr + local.get $oldEnd + i32.ne + if + local.get $oldPtr + local.set $oldEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $newPtr + local.set $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:key" + local.set $oldEntryKey + local.get $newEntry + local.get $oldEntryKey + call $"~lib/map/MapEntry#set:key" + local.get $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:value" + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/MapEntry#set:value" + local.get $oldEntryKey + call $~lib/util/hash/HASH + local.get $newBucketsMask + i32.and + local.set $newBucketIndex + local.get $newBuckets + local.get $newBucketIndex + i32.const 4 + i32.mul + i32.add + local.set $newBucketPtrBase + local.get $newEntry + local.get $newBucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $newBucketPtrBase + local.get $newPtr + i32.store + local.get $newPtr + block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.3" + end + i32.add + local.set $newPtr + end + local.get $oldPtr + block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.4" + end + i32.add + local.set $oldPtr + br $while-continue|0 + end + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBuckets + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBucketsMask + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntries + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntriesCapacity + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#get:entriesCount" + call $"~lib/map/Map#set:entriesOffset" + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) + (local $hashCode i32) + (local $entry i32) + (local $entries i32) + (local $6 i32) + (local $bucketPtrBase i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $key + call $~lib/util/hash/HASH + local.set $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $key + local.get $hashCode + call $"~lib/map/Map#find" + local.set $entry + local.get $entry + if + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.eq + if + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.const 3 + i32.mul + i32.const 4 + i32.div_s + i32.lt_s + if (result i32) + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.const 1 + i32.shl + i32.const 1 + i32.or + end + call $"~lib/map/Map#rehash" + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.tee $entries + i32.store offset=8 + local.get $entries + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.tee $6 + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesOffset" + local.get $6 + block $"~lib/map/ENTRY_SIZE|inlined.5" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.5" + end + i32.mul + i32.add + local.set $entry + local.get $entry + local.get $key + call $"~lib/map/MapEntry#set:key" + i32.const 0 + drop + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + local.set $bucketPtrBase + local.get $entry + local.get $bucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $bucketPtrBase + local.get $entry + i32.store + end + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/memory/MemoryBuilder#getOrCreatePageForAddress (param $this i32) (param $access i32) (param $address i32) (result i32) + (local $pageIdx i32) + (local $page i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $address + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $pageIdx + local.get $pageIdx + global.get $assembly/memory-page/RESERVED_PAGES + i32.lt_u + if + i32.const 9488 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + i32.const 10 + call $~lib/number/U32#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/string/String#concat + i32.const 2048 + i32.const 93 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/MemoryBuilder#get:pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + call $"~lib/map/Map#has" + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/MemoryBuilder#get:arena + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=8 + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/MemoryBuilder#get:pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + i32.const 0 + local.get $access + local.get $page + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory-page/Page#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $"~lib/map/Map#set" + drop + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/MemoryBuilder#get:pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + call $"~lib/map/Map#get" + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.set $sourceStart + i32.const 0 + i32.eqz + drop + local.get $targetStart + local.get $sourceStart + local.get $sourceLen + i32.const 0 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/MemoryBuilder#setData (param $this i32) (param $access i32) (param $address i32) (param $data i32) (result i32) + (local $currentAddress i32) + (local $currentData i32) + (local $page i32) + (local $relAddress i32) + (local $spaceInPage i32) + (local $end i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $address + local.set $currentAddress + global.get $~lib/memory/__stack_pointer + local.get $data + local.tee $currentData + i32.store + loop $while-continue|0 + local.get $currentData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $access + local.get $currentAddress + call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress + local.tee $page + i32.store offset=8 + local.get $currentAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.rem_u + local.set $relAddress + global.get $assembly/memory-page/PAGE_SIZE + local.get $relAddress + i32.sub + local.set $spaceInPage + local.get $currentData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + local.get $spaceInPage + i32.lt_u + if (result i32) + local.get $currentData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + else + local.get $spaceInPage + end + local.set $end + local.get $page + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=20 + local.get $10 + call $assembly/memory-page/Page#get:raw + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=16 + local.get $10 + call $assembly/memory-page/RawPage#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $currentData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=16 + local.get $10 + i32.const 0 + local.get $end + call $~lib/typedarray/Uint8Array#subarray + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + local.get $relAddress + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $currentAddress + local.get $end + i32.add + local.set $currentAddress + global.get $~lib/memory/__stack_pointer + local.get $currentData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $end + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $currentData + i32.store + br $while-continue|0 + end + end + local.get $this + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $assembly/memory/Memory#getU8 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 1 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/typedarray/Uint8Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + i32.ge_u + if + i32.const 480 + i32.const 720 + i32.const 178 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $index + i32.add + local.get $value + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#setU8 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 1 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/memory.test~anonymous|1 (param $$0 i32) (result i32) + (local $builder i32) + (local $mem i32) + (local $a i32) + (local $b i32) + (local $c i32) + (local $d i32) + (local $assert i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store + local.get $builder + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $assembly/memory-page/Access.Read + global.get $assembly/memory-page/RESERVED_MEMORY + i32.const 0 + i32.const 10 + call $~lib/typedarray/Uint8Array#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/MemoryBuilder#setData + drop + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $mem + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $assembly/memory-page/RESERVED_MEMORY + call $assembly/memory/Memory#getU64 + local.tee $a + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $assembly/memory-page/RESERVED_PAGES + i32.const 1 + i32.add + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + call $assembly/memory/Memory#getU8 + local.tee $b + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $assembly/memory-page/RESERVED_MEMORY + i32.const 12 + call $assembly/memory/Memory#setU8 + local.tee $c + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $assembly/memory-page/RESERVED_MEMORY + call $assembly/memory/Memory#getU8 + local.tee $d + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=32 + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $a + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=40 + local.get $8 + call $assembly/memory/Result#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 8944 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $a + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=40 + local.get $8 + call $assembly/memory/Result#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9200 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $a + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/Result#get:ok + i64.const 0 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $b + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=40 + local.get $8 + call $assembly/memory/Result#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 1 + i32.const 9248 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $b + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=40 + local.get $8 + call $assembly/memory/Result#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9296 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $b + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=40 + local.get $8 + call $assembly/memory/Result#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:fault + i32.const 69632 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 1 + i32.const 9728 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 1 + i32.const 9776 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/MaybePageFault#get:fault + i32.const 65536 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $d + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=36 + local.get $8 + call $assembly/memory/Result#get:ok + i64.const 0 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $i i32) + (local $ptr i32) + (local $value i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/array/Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/array/Array#get:dataStart + local.set $sourceStart + i32.const 0 + i32.const 2 + i32.eq + drop + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $sourceLen + i32.lt_s + if + local.get $targetStart + local.get $i + i32.const 0 + i32.shl + i32.add + local.set $ptr + local.get $sourceStart + local.get $i + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + i32.const 0 + drop + local.get $ptr + local.get $value + i32.store8 + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#bytesWrite (param $this i32) (param $address i32) (param $source i32) (result i32) + (local $nextAddress i32) + (local $sourceIndex i32) + (local $bytesLeft i32) + (local $pageData i32) + (local $relAddress i32) + (local $bytesToWrite i32) + (local $sourceData i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + local.get $address + local.set $nextAddress + i32.const 0 + local.set $sourceIndex + loop $while-continue|0 + local.get $sourceIndex + local.get $source + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $source + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + local.get $sourceIndex + i32.sub + local.set $bytesLeft + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + global.get $assembly/memory-page/Access.Write + local.get $nextAddress + call $assembly/memory/Memory#getPage + local.tee $pageData + i32.store offset=4 + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/PageData#get:fault + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:fault + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + end + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:relativeAddress + local.set $relAddress + local.get $relAddress + local.get $bytesLeft + i32.add + global.get $assembly/memory-page/PAGE_SIZE + i32.lt_u + if (result i32) + local.get $bytesLeft + else + global.get $assembly/memory-page/PAGE_SIZE + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:relativeAddress + i32.sub + end + local.set $bytesToWrite + global.get $~lib/memory/__stack_pointer + local.get $source + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $sourceIndex + local.get $sourceIndex + local.get $bytesToWrite + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $sourceData + i32.store offset=12 + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=24 + local.get $10 + call $assembly/memory/PageData#get:page + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=20 + local.get $10 + call $assembly/memory-page/Page#get:raw + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=16 + local.get $10 + call $assembly/memory-page/RawPage#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $sourceData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + local.get $relAddress + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $sourceIndex + local.get $bytesToWrite + i32.add + local.set $sourceIndex + local.get $nextAddress + local.get $bytesToWrite + i32.add + local.set $nextAddress + br $while-continue|0 + end + end + global.get $assembly/memory/NO_PAGE_FAULT + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $assembly/memory/Memory#bytesRead (param $this i32) (param $address i32) (param $destination i32) (result i32) + (local $nextAddress i32) + (local $destinationIndex i32) + (local $bytesLeft i32) + (local $pageData i32) + (local $relAddress i32) + (local $bytesToRead i32) + (local $source i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $address + local.set $nextAddress + i32.const 0 + local.set $destinationIndex + loop $while-continue|0 + local.get $destinationIndex + local.get $destination + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $destination + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + local.get $destinationIndex + i32.sub + local.set $bytesLeft + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + global.get $assembly/memory-page/Access.Read + local.get $nextAddress + call $assembly/memory/Memory#getPage + local.tee $pageData + i32.store offset=4 + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/PageData#get:fault + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:fault + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + end + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:relativeAddress + local.set $relAddress + local.get $relAddress + local.get $bytesLeft + i32.add + global.get $assembly/memory-page/PAGE_SIZE + i32.lt_u + if (result i32) + local.get $bytesLeft + else + global.get $assembly/memory-page/PAGE_SIZE + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:relativeAddress + i32.sub + end + local.set $bytesToRead + global.get $~lib/memory/__stack_pointer + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=16 + local.get $10 + call $assembly/memory/PageData#get:page + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/memory-page/Page#get:raw + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory-page/RawPage#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $relAddress + local.get $relAddress + local.get $bytesToRead + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $source + i32.store offset=20 + local.get $destination + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $source + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + local.get $destinationIndex + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $destinationIndex + local.get $bytesToRead + i32.add + local.set $destinationIndex + local.get $nextAddress + local.get $bytesToRead + i32.add + local.set $nextAddress + br $while-continue|0 + end + end + global.get $assembly/memory/NO_PAGE_FAULT + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $~lib/string/String#substring (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $len i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $finalStart i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $finalEnd i32) + (local $14 i32) + (local $15 i32) + (local $fromPos i32) + (local $17 i32) + (local $18 i32) + (local $toPos i32) + (local $size i32) + (local $out i32) + (local $22 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $~lib/string/String#get:length + local.set $len + local.get $start + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + local.tee $6 + local.get $len + local.tee $7 + local.get $6 + local.get $7 + i32.lt_s + select + local.set $finalStart + local.get $end + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_s + select + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + local.set $finalEnd + local.get $finalStart + local.tee $14 + local.get $finalEnd + local.tee $15 + local.get $14 + local.get $15 + i32.lt_s + select + i32.const 1 + i32.shl + local.set $fromPos + local.get $finalStart + local.tee $17 + local.get $finalEnd + local.tee $18 + local.get $17 + local.get $18 + i32.gt_s + select + i32.const 1 + i32.shl + local.set $toPos + local.get $toPos + local.get $fromPos + i32.sub + local.set $size + local.get $size + i32.eqz + if + i32.const 4080 + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + end + local.get $fromPos + i32.eqz + if (result i32) + local.get $toPos + local.get $len + i32.const 1 + i32.shl + i32.eq + else + i32.const 0 + end + if + local.get $this + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + end + global.get $~lib/memory/__stack_pointer + local.get $size + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $out + local.get $this + local.get $fromPos + i32.add + local.get $size + memory.copy + local.get $out + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + ) + (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $value i32) + (local $sepLen i32) + (local $estLen i32) + (local $result i32) + (local $offset i32) + (local $value|9 i32) + (local $i i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 4080 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $lastIndex + i32.eqz + if + local.get $dataStart + i32.load8_u + local.set $value + i32.const 0 + drop + i32.const 1 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 10 + call $~lib/util/number/utoa32 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $separator + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + local.set $sepLen + i32.const 10 + local.get $sepLen + i32.add + local.get $lastIndex + i32.mul + i32.const 10 + i32.add + local.set $estLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=4 + i32.const 0 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $lastIndex + i32.lt_s + if + local.get $dataStart + local.get $i + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $dataStart + local.get $lastIndex + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $estLen + local.get $offset + i32.gt_s + if + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.const 0 + local.get $offset + call $~lib/string/String#substring + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/typedarray/Uint8Array#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/typedarray/Uint8Array#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/util/string/joinIntegerArray + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/typedarray/Uint8Array#toString (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 10000 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/typedarray/Uint8Array#join + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/string/String.__eq (param $left i32) (param $right i32) (result i32) + (local $leftLength i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $left + local.get $right + i32.eq + if + i32.const 1 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $left + i32.const 0 + i32.eq + if (result i32) + i32.const 1 + else + local.get $right + i32.const 0 + i32.eq + end + if + i32.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $left + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/string/String#get:length + local.set $leftLength + local.get $leftLength + local.get $right + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/string/String#get:length + i32.ne + if + i32.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $left + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 0 + local.get $right + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + local.get $leftLength + call $~lib/util/string/compareImpl + i32.eqz + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/string/String.__ne (param $left i32) (param $right i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $left + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $right + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/string/String.__eq + i32.eqz + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/test/Assert#isEqual<~lib/string/String> (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) + (local $actualDisplay i32) + (local $expectDisplay i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + local.get $actual + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $expected + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/string/String.__ne + if + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 0 + call $assembly/test/Assert#set:isOkay + global.get $~lib/memory/__stack_pointer + local.get $actual + local.tee $actualDisplay + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $expected + local.tee $expectDisplay + i32.store offset=12 + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + call $assembly/test/Assert#get:errors + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + global.get $~lib/memory/__stack_pointer + local.get $actualDisplay + local.tee $6 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $expectDisplay + local.tee $7 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $8 + i32.store offset=28 + i32.const 10128 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 1 + local.get $6 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=32 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 10128 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 3 + local.get $7 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=32 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 10128 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 5 + local.get $8 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=32 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 10128 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 4080 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=32 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/array/Array<~lib/string/String>#push + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/memory.test~anonymous|2 (param $$0 i32) (result i32) + (local $builder i32) + (local $mem i32) + (local $out i32) + (local $data i32) + (local $5 i32) + (local $a i32) + (local $b i32) + (local $c i32) + (local $assert i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + global.get $assembly/memory-page/Access.Write + global.get $assembly/memory-page/RESERVED_MEMORY + i32.const 0 + i32.const 1 + call $~lib/typedarray/Uint8Array#constructor + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/MemoryBuilder#setData + drop + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + global.get $assembly/memory-page/Access.Write + global.get $assembly/memory-page/RESERVED_PAGES + i32.const 1 + i32.add + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + i32.const 0 + i32.const 1 + call $~lib/typedarray/Uint8Array#constructor + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/MemoryBuilder#setData + drop + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $mem + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 16 + call $~lib/typedarray/Uint8Array#constructor + local.tee $out + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $out + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $data + i32.store offset=20 + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + i32.const 4 + i32.const 2 + i32.const 4 + i32.const 9952 + call $~lib/rt/__newArray + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + i32.const 0 + call $~lib/typedarray/Uint8Array#set<~lib/array/Array> + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/PAGE_SIZE + i32.add + i32.const 10 + i32.sub + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/Memory#bytesWrite + local.tee $a + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/PAGE_SIZE + i32.add + i32.const 9 + i32.sub + local.get $out + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/Memory#bytesRead + local.tee $b + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/PAGE_SIZE + i32.const 2 + i32.mul + i32.add + local.get $out + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/Memory#bytesRead + local.tee $c + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=36 + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $a + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 8944 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $a + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9200 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $a + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:fault + i32.const 0 + i32.const 8944 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $b + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 9248 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $b + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9296 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $b + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:fault + i32.const 0 + i32.const 9248 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $c + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 1 + i32.const 9728 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $c + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + call $assembly/memory/MaybePageFault#get:isAccess + i32.const 0 + i32.const 9776 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $out + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=48 + local.get $10 + call $~lib/typedarray/Uint8Array#toString + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + i32.const 10032 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + i32.const 4080 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=44 + local.get $10 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + local.get $10 + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=48 + local.get $10 + call $~lib/typedarray/Uint8Array#toString + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + i32.const 10176 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=40 + local.get $10 + i32.const 4080 + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=44 + local.get $10 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $start:assembly/memory.test~anonymous|3 (param $$0 i32) (result i32) + (local $mem i32) + (local $out i32) + (local $a i32) + (local $b i32) + (local $c i32) + (local $d i32) + (local $e i32) + (local $assert i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + global.get $assembly/memory-page/Access.Read + global.get $assembly/memory-page/RESERVED_MEMORY + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MemoryBuilder#setData + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $assembly/memory/MemoryBuilder#build@varargs + local.tee $mem + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.tee $out + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 0 + local.get $out + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/memory/Memory#bytesRead + local.tee $a + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 0 + local.get $out + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/memory/Memory#bytesWrite + local.tee $b + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/RESERVED_MEMORY + i32.add + local.get $out + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/memory/Memory#bytesRead + local.tee $c + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + global.get $assembly/memory-page/RESERVED_MEMORY + global.get $assembly/memory-page/RESERVED_MEMORY + i32.add + local.get $out + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/memory/Memory#bytesRead + local.tee $d + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $mem + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + global.get $assembly/memory-page/RESERVED_MEMORY + local.get $out + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/memory/Memory#bytesWrite + local.tee $e + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=40 + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $a + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 8944 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $b + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 9248 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $c + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 9728 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $d + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 10448 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $e + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/memory/MaybePageFault#get:isFault + i32.const 0 + i32.const 10496 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $start:assembly/memory.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 8496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 9344 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 9376 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 9824 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 9856 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 10288 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + i32.const 10320 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 10544 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/memory.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/jump~anonymous|0 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:a + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/instructions/outcome/dJump (param $address i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.DynamicJump + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $address + call $assembly/instructions/outcome/OutcomeData#set:dJump + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/jump~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $address i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + local.get $address + call $assembly/instructions/outcome/dJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/jump~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/outcome/staticJump + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/jump~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $address i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:d + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + local.get $address + call $assembly/instructions/outcome/dJump + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.const 32 + i64.shl + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/load~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/instructions/outcome/okOrFault (param $pageFault i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MaybePageFault#get:isAccess + if (result i32) + global.get $assembly/instructions/outcome/Result.FAULT_ACCESS + else + global.get $assembly/instructions/outcome/Result.FAULT + end + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $pageFault + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/MaybePageFault#get:fault + call $assembly/instructions/outcome/OutcomeData#set:exitCode + end + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/load~anonymous|2 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|3 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU16 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getI16 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $l i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 2 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/Result#set:fault + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.const 15 + i32.and + i32.shl + i32.or + local.set $l + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $l + call $assembly/instructions/utils/u16SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getU32 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#set:fault + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/ChunkBytes#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/memory/Result#get:ok + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/memory/ChunkBytes#get:bytes + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i64.extend_i32_u + i64.or + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/memory/Memory#getI32 (param $this i32) (param $address i32) (result i32) + (local $res i32) + (local $r i32) + (local $l i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + global.get $assembly/memory-page/Access.Read + local.get $address + i32.const 4 + call $assembly/memory/Memory#getBytes + local.tee $res + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $r + i32.store offset=8 + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/Result#set:fault + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $~lib/staticarray/StaticArray#__get + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + call $~lib/staticarray/StaticArray#__get + i32.const 8 + i32.shl + i32.or + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 2 + call $~lib/staticarray/StaticArray#__get + i32.const 16 + i32.shl + i32.or + local.set $l + local.get $l + local.get $res + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/ChunkBytes#get:bytes + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 3 + call $~lib/staticarray/StaticArray#__get + i32.const 24 + i32.shl + i32.or + local.set $l + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $l + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Result#set:ok + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getI32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#getU64 + local.tee $result + i32.store offset=8 + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI8 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI16 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getI32 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/load~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + call $assembly/memory/Memory#getU64 + local.tee $result + i32.store offset=8 + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory/MaybePageFault#get:isFault + i32.eqz + if + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + end + local.get $result + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/Result#get:fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/mov~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/set~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.lt_u + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.lt_s + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.gt_u + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.gt_s + local.set $cond + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_u + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/set~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_s + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/shift~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $imm i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $imm + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $imm + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $regValue i64) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + local.set $regValue + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regValue + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|0 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU16 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 2 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.gt_s + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $value + i32.const 65535 + i32.and + i32.const 8 + i32.const 15 + i32.and + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + else + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 65535 + i32.and + i32.const 8 + i32.const 15 + i32.and + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|1 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU32 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $v i32) + (local $len i32) + (local $i i32) + (local $i|7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 4 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $value + local.set $v + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + local.get $v + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i32.const 8 + i32.shr_u + local.set $v + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i|7 + local.get $v + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i32.const 8 + i32.shr_u + local.set $v + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/instructions/store~anonymous|2 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/memory/Memory#setU32 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/memory/Memory#setU64 (param $this i32) (param $address i32) (param $value i64) (result i32) + (local $res i32) + (local $v i64) + (local $len i32) + (local $i i32) + (local $i|7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 8 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $value + local.set $v + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + local.get $v + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i64.const 8 + i64.shr_u + local.set $v + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i|7 + local.get $v + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i64.const 8 + i64.shr_u + local.set $v + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/instructions/store~anonymous|3 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:a + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Memory#setU64 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/store~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/memory/Memory#setU32 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Memory#setU64 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/instructions/outcome/status (param $result i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $result + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) + (local $r i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Result.HOST + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $id + call $assembly/instructions/outcome/OutcomeData#set:exitCode + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $assembly/arguments/Args#get:a + call $assembly/instructions/outcome/hostCall + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) + (local $freeMemoryStart i32) + (local $newSbrk i64) + (local $pageIdx i32) + (local $i i32) + (local $page i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $freeMemoryStart + i32.store + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $amount + i32.const 0 + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + local.get $amount + i64.extend_i32_u + i64.add + local.set $newSbrk + local.get $newSbrk + global.get $assembly/memory/MEMORY_SIZE + i64.ge_s + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Result#get:fault + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isFault + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $newSbrk + i32.wrap_i64 + call $assembly/memory/Memory#set:sbrkAddress + local.get $newSbrk + i64.const 1 + i64.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + local.set $pageIdx + local.get $pageIdx + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.const 1 + i32.add + local.set $i + loop $for-loop|0 + local.get $i + local.get $pageIdx + i32.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:arena + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=12 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory/Memory#get:pages + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $i + i32.const 0 + global.get $assembly/memory-page/Access.Write + local.get $page + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory-page/Page#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $"~lib/map/Map#set" + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $pageIdx + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#sbrk + local.tee $res + i32.store offset=12 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/codec~anonymous|0 (param $firstByte i32) (result i32) + (local $len i32) + (local $i i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $assembly/codec/MASKS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.const 255 + i32.and + i32.lt_u + if + local.get $firstByte + i32.const 255 + i32.and + global.get $assembly/codec/MASKS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $i + call $~lib/array/Array#__get + i32.ge_u + if + i32.const 8 + local.get $i + i32.sub + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 1888 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 13920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/MISSING_INSTRUCTION + i32.const 13968 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + global.set $assembly/instructions/SBRK + global.get $~lib/memory/__stack_pointer + i32.const 231 + i32.const 2 + i32.const 36 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.const 14000 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 14032 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.Zero + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 5 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 6 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 7 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 8 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 9 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 10 + i32.const 14080 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 11 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 12 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 13 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 14 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 15 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 16 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 17 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 18 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 19 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 20 + i32.const 14112 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneExtImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 21 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 22 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 23 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 24 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 25 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 26 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 27 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 28 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 29 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 30 + i32.const 14160 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 31 + i32.const 14208 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 32 + i32.const 14256 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 33 + i32.const 14304 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 34 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 35 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 36 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 37 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 38 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 39 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 40 + i32.const 14352 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 41 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 42 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 43 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 44 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 45 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 46 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 47 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 48 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 49 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 50 + i32.const 14384 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 51 + i32.const 14432 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 52 + i32.const 14480 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 53 + i32.const 14528 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 54 + i32.const 14576 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 55 + i32.const 14624 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 56 + i32.const 14672 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 57 + i32.const 14720 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 58 + i32.const 14768 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 59 + i32.const 14816 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 60 + i32.const 14864 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 61 + i32.const 14912 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 62 + i32.const 14960 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 63 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 64 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 65 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 66 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 67 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 68 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 69 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 70 + i32.const 15008 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 71 + i32.const 15072 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 72 + i32.const 15136 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 73 + i32.const 15200 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 74 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 75 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 76 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 77 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 78 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 79 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 80 + i32.const 15264 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 81 + i32.const 15312 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 82 + i32.const 15360 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 83 + i32.const 15408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 84 + i32.const 15472 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 85 + i32.const 15536 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 86 + i32.const 15600 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 87 + i32.const 15664 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 88 + i32.const 15728 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 89 + i32.const 15792 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 90 + i32.const 15856 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 91 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 92 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 93 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 94 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 95 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 96 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 97 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 98 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 99 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 100 + i32.const 15920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 101 + global.get $assembly/instructions/SBRK + call $~lib/array/Array#__set + local.get $0 + i32.const 102 + i32.const 15968 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 103 + i32.const 16032 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 104 + i32.const 16096 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 105 + i32.const 16160 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 106 + i32.const 16224 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 107 + i32.const 16288 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 108 + i32.const 16352 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 109 + i32.const 16400 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 110 + i32.const 16448 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 111 + i32.const 16496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 112 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 113 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 114 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 115 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 116 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 117 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 118 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 119 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 120 + i32.const 16544 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 121 + i32.const 16592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 122 + i32.const 16640 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 123 + i32.const 16688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 124 + i32.const 16736 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 125 + i32.const 16784 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 126 + i32.const 16832 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 127 + i32.const 16880 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 128 + i32.const 16928 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 129 + i32.const 16976 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 130 + i32.const 17024 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 131 + i32.const 17072 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 132 + i32.const 17120 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 133 + i32.const 17168 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 134 + i32.const 17216 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 135 + i32.const 17248 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 136 + i32.const 17296 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 137 + i32.const 17344 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 138 + i32.const 17392 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 139 + i32.const 17440 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 140 + i32.const 17488 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 141 + i32.const 17536 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 142 + i32.const 17584 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 143 + i32.const 17632 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 144 + i32.const 17680 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 145 + i32.const 17744 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 146 + i32.const 17808 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 147 + i32.const 17872 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 148 + i32.const 17920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 149 + i32.const 17968 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 150 + i32.const 18016 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 151 + i32.const 18064 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 152 + i32.const 18112 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 153 + i32.const 18160 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 154 + i32.const 18208 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 155 + i32.const 18256 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 156 + i32.const 18320 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 157 + i32.const 18384 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 158 + i32.const 18448 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 159 + i32.const 18496 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 160 + i32.const 18560 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 161 + i32.const 18608 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 162 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 163 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 164 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 165 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 166 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 167 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 168 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 169 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 170 + i32.const 18672 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 171 + i32.const 18720 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 172 + i32.const 18768 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 173 + i32.const 18816 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 174 + i32.const 18864 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 175 + i32.const 18912 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 176 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 177 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 178 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 179 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 180 + i32.const 18960 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.TwoRegTwoImm + i64.const 1 + i32.const 1 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 181 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 182 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 183 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 184 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 185 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 186 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 187 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 188 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 189 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $~lib/array/Array#__set + local.get $0 + i32.const 190 + i32.const 19024 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 191 + i32.const 19056 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 192 + i32.const 19088 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 193 + i32.const 19120 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 194 + i32.const 19168 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 195 + i32.const 19216 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 196 + i32.const 19264 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 197 + i32.const 19312 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 198 + i32.const 19360 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 199 + i32.const 19408 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 200 + i32.const 19456 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 201 + i32.const 19488 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 202 + i32.const 19520 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 203 + i32.const 19552 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 204 + i32.const 19600 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 205 + i32.const 19648 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 206 + i32.const 19696 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 207 + i32.const 19744 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 208 + i32.const 19792 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 209 + i32.const 19840 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 210 + i32.const 19888 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 211 + i32.const 19920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 212 + i32.const 19952 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 213 + i32.const 19984 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 214 + i32.const 20032 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 215 + i32.const 20080 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 216 + i32.const 20128 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 217 + i32.const 20176 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 218 + i32.const 20224 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 219 + i32.const 20272 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 220 + i32.const 20320 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 221 + i32.const 20368 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 222 + i32.const 20416 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 223 + i32.const 20464 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 224 + i32.const 20512 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 225 + i32.const 20560 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 226 + i32.const 20592 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 227 + i32.const 20624 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 228 + i32.const 20656 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 229 + i32.const 20688 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + i32.const 230 + i32.const 20720 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + global.get $assembly/arguments/Arguments.ThreeReg + i64.const 1 + i32.const 0 + call $assembly/instructions/instruction + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/instructions/INSTRUCTIONS + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/Mask#constructor (param $this i32) (param $packedMask i32) (param $codeLength i32) (result i32) + (local $lastInstructionOffset i32) + (local $i i32) + (local $bits i32) + (local $index i32) + (local $b i32) + (local $isSet i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 37 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + call $assembly/program/Mask#set:bytesToSkip + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + local.get $codeLength + call $~lib/staticarray/StaticArray#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/Mask#set:bytesToSkip + i32.const 0 + local.set $lastInstructionOffset + local.get $packedMask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.sub + local.set $i + loop $for-loop|0 + local.get $i + i32.const 0 + i32.ge_s + if + local.get $packedMask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $bits + local.get $i + i32.const 8 + i32.mul + local.set $index + i32.const 7 + local.set $b + loop $for-loop|2 + local.get $b + i32.const 0 + i32.ge_s + if + local.get $bits + i32.const 128 + i32.and + local.set $isSet + local.get $bits + i32.const 1 + i32.const 7 + i32.and + i32.shl + local.set $bits + local.get $index + local.get $b + i32.add + local.get $codeLength + i32.lt_s + if + local.get $isSet + if (result i32) + i32.const 0 + else + local.get $lastInstructionOffset + i32.const 1 + i32.add + end + local.set $lastInstructionOffset + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/Mask#get:bytesToSkip + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $index + local.get $b + i32.add + local.get $lastInstructionOffset + global.get $assembly/program/MAX_SKIP + i32.const 1 + i32.add + i32.lt_u + if (result i32) + local.get $lastInstructionOffset + else + global.get $assembly/program/MAX_SKIP + i32.const 1 + i32.add + end + call $~lib/staticarray/StaticArray#__set + end + local.get $b + i32.const 1 + i32.sub + local.set $b + br $for-loop|2 + end + end + local.get $i + i32.const 1 + i32.sub + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $i i32) + (local $ptr i32) + (local $value f64) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/array/Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + local.get $12 + call $~lib/array/Array#get:dataStart + local.set $sourceStart + i32.const 1 + i32.const 0 + i32.eq + drop + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $sourceLen + i32.lt_s + if + local.get $targetStart + local.get $i + i32.const 0 + i32.shl + i32.add + local.set $ptr + local.get $sourceStart + local.get $i + i32.const 3 + i32.shl + i32.add + f64.load + local.set $value + i32.const 0 + drop + i32.const 0 + i32.eqz + drop + local.get $ptr + local.get $value + local.get $value + f64.sub + f64.const 0 + f64.eq + if (result i32) + local.get $value + i32.trunc_sat_f64_u + else + i32.const 0 + end + i32.store8 + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program.test/u8arr (param $data i32) (result i32) + (local $ret i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $ret + i32.store offset=4 + local.get $ret + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#set<~lib/array/Array> + local.get $ret + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/staticarray/StaticArray#slice<~lib/array/Array> (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $length i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $sourceStart i32) + (local $size i32) + (local $out i32) + (local $outStart i32) + (local $18 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $18 + global.get $~lib/memory/__stack_pointer + local.get $18 + i32.store + local.get $18 + call $~lib/staticarray/StaticArray#get:length + local.set $length + local.get $start + i32.const 0 + i32.lt_s + if (result i32) + local.get $start + local.get $length + i32.add + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + else + local.get $start + local.tee $6 + local.get $length + local.tee $7 + local.get $6 + local.get $7 + i32.lt_s + select + end + local.set $start + local.get $end + i32.const 0 + i32.lt_s + if (result i32) + local.get $end + local.get $length + i32.add + local.tee $8 + i32.const 0 + local.tee $9 + local.get $8 + local.get $9 + i32.gt_s + select + else + local.get $end + local.tee $10 + local.get $length + local.tee $11 + local.get $10 + local.get $11 + i32.lt_s + select + end + local.set $end + local.get $end + local.get $start + i32.sub + local.tee $12 + i32.const 0 + local.tee $13 + local.get $12 + local.get $13 + i32.gt_s + select + local.set $length + local.get $this + local.get $start + i32.const 2 + i32.shl + i32.add + local.set $sourceStart + local.get $length + i32.const 2 + i32.shl + local.set $size + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $out + i32.store offset=4 + i32.const 1 + drop + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 2 + i32.const 40 + i32.const 0 + call $~lib/rt/__newArray + local.tee $out + i32.store offset=4 + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + local.get $18 + i32.store + local.get $18 + call $~lib/array/Array#get:dataStart + local.set $outStart + i32.const 0 + drop + local.get $outStart + local.get $sourceStart + local.get $size + memory.copy + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + ) + (func $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $start + end + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $start + local.get $end + call $~lib/staticarray/StaticArray#slice<~lib/array/Array> + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $value i32) + (local $sepLen i32) + (local $estLen i32) + (local $result i32) + (local $offset i32) + (local $value|9 i32) + (local $i i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 4080 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $lastIndex + i32.eqz + if + local.get $dataStart + i32.load + local.set $value + i32.const 0 + drop + i32.const 4 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 10 + call $~lib/util/number/utoa32 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $separator + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + local.set $sepLen + i32.const 10 + local.get $sepLen + i32.add + local.get $lastIndex + i32.mul + i32.const 10 + i32.add + local.set $estLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=4 + i32.const 0 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $lastIndex + i32.lt_s + if + local.get $dataStart + local.get $i + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $dataStart + local.get $lastIndex + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $estLen + local.get $offset + i32.gt_s + if + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.const 0 + local.get $offset + call $~lib/string/String#substring + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/array/Array#join (param $this i32) (param $separator i32) (result i32) + (local $ptr i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.set $ptr + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $len + i32.const 0 + drop + i32.const 1 + drop + local.get $ptr + local.get $len + local.get $separator + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/util/string/joinIntegerArray + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/test/Assert#isArrayEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $actual + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $~lib/array/Array#get:length + local.get $expected + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $~lib/array/Array#get:length + i32.const 21008 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $msg + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $~lib/string/String#concat + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/test/Assert#isEqual + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $actual + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + local.get $4 + i32.const 10000 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=24 + local.get $4 + call $~lib/array/Array#join + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $~lib/string/String#toString + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $expected + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + local.get $4 + i32.const 10000 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=24 + local.get $4 + call $~lib/array/Array#join + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $~lib/string/String#toString + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $msg + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/test/Assert#isEqual<~lib/string/String> + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/Mask#isInstruction (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + i64.extend_i32_u + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i64.extend_i32_s + i64.ge_u + if + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $index + call $~lib/staticarray/StaticArray#__get + i32.const 0 + i32.eq + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/program/Mask#skipBytesToNextInstruction (param $this i32) (param $i i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $i + i32.const 1 + i32.add + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i32.lt_u + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $i + i32.const 1 + i32.add + call $~lib/staticarray/StaticArray#__get + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/program.test~anonymous|0 (param $$0 i32) (result i32) + (local $1 i32) + (local $mask i32) + (local $assert i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 3 + i32.const 3 + i32.const 39 + i32.const 20848 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program.test/u8arr + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 21 + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/program/Mask#get:bytesToSkip + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + i32.const 0 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 21 + i32.const 2 + i32.const 40 + i32.const 20896 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isArrayEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 0 + call $assembly/program/Mask#isInstruction + i32.const 0 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 4 + call $assembly/program/Mask#isInstruction + i32.const 1 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 20 + call $assembly/program/Mask#skipBytesToNextInstruction + i32.const 0 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 22 + call $assembly/program/Mask#skipBytesToNextInstruction + i32.const 0 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/program.test~anonymous|1 (param $$0 i32) (result i32) + (local $1 i32) + (local $mask i32) + (local $assert i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 4 + i32.const 3 + i32.const 39 + i32.const 21200 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program.test/u8arr + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 32 + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/program/Mask#get:bytesToSkip + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + i32.const 0 + i32.const 0 + global.set $~argumentsLength + i32.const 0 + call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 32 + i32.const 2 + i32.const 40 + i32.const 21264 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/test/Assert#isArrayEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 21616 + i32.const 1888 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/decodeArguments (param $kind i32) (param $data i32) (param $lim i32) (result i32) + (local $extended i32) + (local $i i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + global.get $assembly/arguments/REQUIRED_BYTES + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $kind + call $~lib/array/Array#__get + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/arguments/REQUIRED_BYTES + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $kind + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#constructor + local.tee $extended + i32.store offset=4 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $extended + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $extended + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $lim + i32.const 2 + global.set $~argumentsLength + global.get $assembly/arguments/DECODERS + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $kind + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $3) + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $lim + i32.const 2 + global.set $~argumentsLength + global.get $assembly/arguments/DECODERS + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $kind + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $3) + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/program.test~anonymous|2 (param $$0 i32) (result i32) + (local $1 i32) + (local $data i32) + (local $args i32) + (local $assert i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 3 + i32.const 39 + i32.const 21552 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program.test/u8arr + local.tee $data + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + global.get $assembly/arguments/Arguments.OneImm + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 4 + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:a + i32.const -1 + i32.const 21744 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 0 + i32.const 21776 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 0 + i32.const 21808 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:d + i32.const 0 + i32.const 21840 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/program.test~anonymous|3 (param $$0 i32) (result i32) + (local $1 i32) + (local $data i32) + (local $args i32) + (local $assert i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 2 + i32.const 3 + i32.const 39 + i32.const 22000 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program.test/u8arr + local.tee $data + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + global.get $assembly/arguments/Arguments.OneImm + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:a + i32.const 5 + i32.const 21744 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:b + i32.const 0 + i32.const 21776 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 0 + i32.const 21808 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/arguments/Args#get:d + i32.const 0 + i32.const 21840 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/test/Assert#isEqual + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/codec/Decoder#constructor (param $this i32) (param $source i32) (param $offset i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 45 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $source + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/codec/Decoder#set:source + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $offset + call $assembly/codec/Decoder#set:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/codec/Decoder#ensureBytes (param $this i32) (param $need i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#get:offset + local.get $need + i32.add + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/codec/Decoder#get:source + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $need + i32.const 10 + call $~lib/number/U32#toString + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/codec/Decoder#get:source + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#get:offset + i32.sub + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=12 + i32.const 22624 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $2 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 22624 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 3 + local.get $3 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 22624 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 4080 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 22672 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/ValOffset#constructor (param $this i32) (param $value i32) (param $offset i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 46 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $value + call $assembly/codec/ValOffset#set:value + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $offset + call $assembly/codec/ValOffset#set:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/codec/decodeVarU32 (param $data i32) (result i32) + (local $length i32) + (local $first i32) + (local $3 i32) + (local $4 i32) + (local $msb i32) + (local $number i32) + (local $i i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + i32.const 1 + global.set $~argumentsLength + global.get $assembly/codec/variableLength + i32.load + call_indirect (type $0) + i32.const 255 + i32.and + local.set $length + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $first + local.get $length + i32.const 0 + i32.eq + if + i32.const 0 + local.get $first + i32.const 1 + call $assembly/codec/ValOffset#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.get $length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.const 10 + call $~lib/number/I32#toString + local.tee $4 + i32.store offset=8 + i32.const 22896 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $3 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 22896 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 3 + local.get $4 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 22896 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 22672 + i32.const 108 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $first + i32.const 2 + i32.const 8 + local.get $length + i32.sub + call $~lib/math/ipow32 + i32.add + i32.const 2 + i32.const 8 + call $~lib/math/ipow32 + i32.sub + local.get $length + i32.const 8 + i32.mul + i32.shl + local.set $msb + i32.const 0 + local.set $number + local.get $length + i32.const 1 + i32.sub + local.set $i + loop $for-loop|0 + local.get $i + i32.const 0 + i32.ge_s + if + local.get $number + i32.const 8 + i32.shl + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $i + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.add + local.set $number + local.get $i + i32.const 1 + i32.sub + local.set $i + br $for-loop|0 + end + end + local.get $number + local.get $msb + i32.add + local.set $number + i32.const 0 + local.get $number + i32.const 1 + local.get $length + i32.add + call $assembly/codec/ValOffset#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/codec/Decoder#varU32 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/codec/decodeVarU32 + local.tee $v + i32.store offset=12 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/ValOffset#get:offset + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/codec/ValOffset#get:value + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u8 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#bytes (param $this i32) (param $len i32) (result i32) + (local $v i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $len + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:source + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $len + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $v + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $len + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/JumpTable#constructor (param $this i32) (param $itemBytes i32) (param $data i32) (result i32) + (local $jumps i32) + (local $i i32) + (local $num i64) + (local $j i32) + (local $nextNum i64) + (local $isOverflow i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 42 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + call $assembly/program/JumpTable#set:jumps + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $itemBytes + i32.const 255 + i32.and + i32.const 0 + i32.gt_u + if (result i32) + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.get $itemBytes + i32.const 255 + i32.and + i32.div_s + else + i32.const 0 + end + call $~lib/staticarray/StaticArray#constructor + local.tee $jumps + i32.store offset=8 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + i64.const 0 + local.set $num + local.get $itemBytes + i32.const 1 + i32.sub + i32.const 255 + i32.and + local.set $j + loop $for-loop|1 + local.get $j + i32.const 0 + i32.ge_s + if + local.get $num + i64.const 8 + i64.shl + local.set $nextNum + local.get $nextNum + local.get $num + i64.lt_u + local.set $isOverflow + local.get $nextNum + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + local.get $j + i32.add + call $~lib/typedarray/Uint8Array#__get + i64.extend_i32_u + i64.add + local.set $nextNum + local.get $isOverflow + if (result i32) + i32.const 1 + else + local.get $nextNum + local.get $num + i64.lt_u + end + local.set $isOverflow + local.get $isOverflow + if (result i64) + global.get $~lib/builtins/u64.MAX_VALUE + else + local.get $nextNum + end + local.set $num + local.get $j + i32.const 1 + i32.sub + local.set $j + br $for-loop|1 + end + end + local.get $jumps + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + local.get $itemBytes + i32.const 255 + i32.and + i32.div_s + local.get $num + call $~lib/staticarray/StaticArray#__set + local.get $i + local.get $itemBytes + i32.const 255 + i32.and + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $jumps + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $assembly/program/JumpTable#set:jumps + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 21616 + i32.const 1888 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 1408 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/BasicBlocks#constructor (param $this i32) (param $code i32) (param $mask i32) (result i32) + (local $len i32) + (local $isStartOrEnd i32) + (local $n i32) + (local $isInstructionInMask i32) + (local $skipArgs i32) + (local $iData i32) + (local $isTerminating i32) + (local $newBlockStart i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 43 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + call $assembly/program/BasicBlocks#set:isStartOrEnd + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $len + call $~lib/staticarray/StaticArray#constructor + local.tee $isStartOrEnd + i32.store offset=8 + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + i32.const 0 + local.set $n + loop $for-loop|0 + local.get $n + local.get $len + i32.lt_s + if + block $for-continue|0 + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $assembly/program/Mask#isInstruction + local.set $isInstructionInMask + local.get $isInstructionInMask + i32.eqz + if + br $for-continue|0 + end + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipArgs + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#__get + end + local.set $iData + local.get $iData + call $assembly/instructions/Instruction#get:isTerminating + local.set $isTerminating + local.get $isTerminating + if + local.get $n + i32.const 1 + i32.add + local.get $skipArgs + i32.add + local.set $newBlockStart + local.get $newBlockStart + local.get $len + i32.lt_s + if + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $newBlockStart + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + end + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + local.get $n + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.END + i32.or + call $~lib/staticarray/StaticArray#__set + end + end + local.get $n + i32.const 1 + i32.add + local.set $n + br $for-loop|0 + end + end + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + call $assembly/program/BasicBlocks#set:isStartOrEnd + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + ) + (func $assembly/program/Program#constructor (param $this i32) (param $code i32) (param $mask i32) (param $jumpTable i32) (param $basicBlocks i32) (result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 41 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $code + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:code + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:mask + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:jumpTable + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $basicBlocks + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:basicBlocks + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + ) + (func $assembly/program/deblob (param $program i32) (result i32) + (local $decoder i32) + (local $jumpTableLength i32) + (local $jumpTableItemLength i32) + (local $codeLength i32) + (local $jumpTableLengthInBytes i32) + (local $rawJumpTable i32) + (local $rawCode i32) + (local $rawMask i32) + (local $mask i32) + (local $jumpTable i32) + (local $basicBlocks i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $program + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#varU32 + local.set $jumpTableLength + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#u8 + local.set $jumpTableItemLength + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#varU32 + local.set $codeLength + local.get $jumpTableLength + local.get $jumpTableItemLength + i32.mul + local.set $jumpTableLengthInBytes + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $jumpTableLengthInBytes + call $assembly/codec/Decoder#bytes + local.tee $rawJumpTable + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + call $assembly/codec/Decoder#bytes + local.tee $rawCode + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + i32.const 7 + i32.add + i32.const 8 + i32.div_u + call $assembly/codec/Decoder#bytes + local.tee $rawMask + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $rawMask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $jumpTableItemLength + local.get $rawJumpTable + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/program/JumpTable#constructor + local.tee $jumpTable + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $rawCode + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $mask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=28 + local.get $12 + call $assembly/program/BasicBlocks#constructor + local.tee $basicBlocks + i32.store offset=32 + i32.const 0 + local.get $rawCode + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $mask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=28 + local.get $12 + local.get $jumpTable + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=36 + local.get $12 + local.get $basicBlocks + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=40 + local.get $12 + call $assembly/program/Program#constructor + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $~lib/string/String.__concat (param $left i32) (param $right i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $left + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $right + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/string/String#concat + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/program/Mask#toString (param $this i32) (result i32) + (local $v i32) + (local $i i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 22944 + local.tee $v + i32.store + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/program/Mask#get:bytesToSkip + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=24 + local.get $3 + call $assembly/program/Mask#get:bytesToSkip + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=20 + local.get $3 + local.get $i + call $~lib/staticarray/StaticArray#__get + i32.const 10 + call $~lib/number/U32#toString + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + i32.const 22976 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + call $~lib/string/String#concat + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $~lib/string/String.__concat + local.tee $v + i32.store + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $v + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 23008 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $~lib/string/String#concat + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/JumpTable#toString (param $this i32) (result i32) + (local $v i32) + (local $i i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 23280 + local.tee $v + i32.store + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/JumpTable#get:jumps + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $~lib/memory/__stack_pointer + local.get $i + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $assembly/program/JumpTable#get:jumps + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + local.get $i + call $~lib/staticarray/StaticArray#__get + i32.const 10 + call $~lib/number/U64#toString + local.tee $4 + i32.store offset=24 + i32.const 23360 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 0 + local.get $3 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 23360 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 2 + local.get $4 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 23360 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/string/String.__concat + local.tee $v + i32.store + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $v + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 23008 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $~lib/string/String#concat + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/program/BasicBlocks#toString (param $this i32) (result i32) + (local $v i32) + (local $i i32) + (local $t i32) + (local $isStart i32) + (local $isEnd i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 23456 + local.tee $v + i32.store + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 4080 + local.tee $t + i32.store offset=12 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $i + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.START + i32.and + i32.const 0 + i32.gt_s + local.set $isStart + global.get $~lib/memory/__stack_pointer + local.get $t + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $isStart + if (result i32) + i32.const 23504 + else + i32.const 4080 + end + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String.__concat + local.tee $t + i32.store offset=12 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $i + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.END + i32.and + i32.const 0 + i32.gt_s + local.set $isEnd + global.get $~lib/memory/__stack_pointer + local.get $t + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $isEnd + if (result i32) + i32.const 23536 + else + i32.const 4080 + end + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String.__concat + local.tee $t + i32.store offset=12 + local.get $t + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $~lib/string/String#get:length + i32.const 0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + global.get $~lib/memory/__stack_pointer + local.get $i + i32.const 10 + call $~lib/number/I32#toString + local.tee $6 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $t + local.tee $7 + i32.store offset=20 + i32.const 23568 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 0 + local.get $6 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 23568 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 2 + local.get $7 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 23568 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String.__concat + local.tee $v + i32.store + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $v + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 23008 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/program.test~anonymous|4 (param $$0 i32) (result i32) + (local $1 i32) + (local $raw i32) + (local $program i32) + (local $assert i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 41 + i32.const 3 + i32.const 39 + i32.const 22144 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program.test/u8arr + local.tee $raw + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $raw + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program/deblob + local.tee $program + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $program + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=32 + local.get $5 + call $assembly/program/Program#get:mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/program/Mask#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 23040 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $program + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=32 + local.get $5 + call $assembly/program/Program#get:jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/program/JumpTable#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 23408 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $program + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=32 + local.get $5 + call $assembly/program/Program#get:basicBlocks + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + local.get $5 + call $assembly/program/BasicBlocks#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + i32.const 23616 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=20 + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=24 + local.get $5 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#indexOf (param $this i32) (param $value i32) (param $fromIndex i32) (result i32) + (local $len i32) + (local $4 i32) + (local $5 i32) + (local $ptr i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ + local.set $len + local.get $len + i32.const 0 + i32.eq + if (result i32) + i32.const 1 + else + local.get $fromIndex + local.get $len + i32.ge_s + end + if + i32.const -1 + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $fromIndex + i32.const 0 + i32.lt_s + if + local.get $len + local.get $fromIndex + i32.add + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + local.set $fromIndex + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart + local.set $ptr + loop $while-continue|0 + local.get $fromIndex + local.get $len + i32.lt_s + if + local.get $ptr + local.get $fromIndex + i32.const 2 + i32.shl + i32.add + i32.load + local.get $value + i32.eq + if + local.get $fromIndex + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $fromIndex + i32.const 1 + i32.add + local.set $fromIndex + br $while-continue|0 + end + end + i32.const -1 + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $assembly/program.test/opcode (param $search i32) (result f64) + (local $idx i32) + (local $2 i32) + (local $3 f64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $assembly/instructions-exe/RUN + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $search + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#indexOf + local.set $idx + local.get $idx + i32.const 0 + i32.lt_s + if + i32.const 24080 + i32.const 24192 + i32.const 152 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $idx + f64.convert_i32_s + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value f64) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 1888 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 3 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 3 + i32.shl + i32.add + local.get $value + f64.store + i32.const 0 + drop + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/program.test~anonymous|5 (param $$0 i32) (result i32) + (local $1 i32) + (local $code i32) + (local $3 i32) + (local $mask i32) + (local $basicBlocks i32) + (local $assert i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.const 3 + i32.const 39 + i32.const 0 + call $~lib/rt/__newArray + local.tee $1 + i32.store offset=4 + local.get $1 + i32.const 0 + global.get $assembly/instructions/misc/trap + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/program.test/opcode + call $~lib/array/Array#__set + local.get $1 + i32.const 1 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 2 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 3 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 4 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 5 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 6 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 7 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 8 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 9 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 10 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 11 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 12 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 13 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 14 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 15 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 16 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 17 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 18 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 19 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 20 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 21 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 22 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 23 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 24 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 25 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 26 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 27 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 28 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 29 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 30 + f64.const 0 + call $~lib/array/Array#__set + local.get $1 + i32.const 31 + global.get $assembly/instructions/jump/jump_ind + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/program.test/opcode + call $~lib/array/Array#__set + local.get $1 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $assembly/program.test/u8arr + local.tee $code + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 4 + i32.const 3 + i32.const 39 + i32.const 24272 + call $~lib/rt/__newArray + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/program.test/u8arr + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + i32.const 32 + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $code + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $mask + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/program/BasicBlocks#constructor + local.tee $basicBlocks + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=24 + local.get $assert + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $mask + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=36 + local.get $7 + call $assembly/program/Mask#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + i32.const 24336 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=28 + local.get $7 + i32.const 4080 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=32 + local.get $7 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $basicBlocks + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=36 + local.get $7 + call $assembly/program/BasicBlocks#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + i32.const 24608 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=28 + local.get $7 + i32.const 4080 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=32 + local.get $7 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $start:assembly/program.test~anonymous|6 (param $$0 i32) (result i32) + (local $1 i32) + (local $jumpTable i32) + (local $assert i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 10 + i32.const 30 + i32.const 3 + i32.const 39 + i32.const 24880 + call $~lib/rt/__newArray + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/program.test/u8arr + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/program/JumpTable#constructor + local.tee $jumpTable + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=12 + local.get $assert + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $jumpTable + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=24 + local.get $4 + call $assembly/program/JumpTable#toString + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 25152 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + i32.const 4080 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=20 + local.get $4 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/program.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + call $start:assembly/program + global.get $~lib/memory/__stack_pointer + i32.const 7 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 20752 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 21056 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 1 + i32.const 21088 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 21424 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 2 + i32.const 21456 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 21872 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 3 + i32.const 21904 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 22048 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 4 + i32.const 22080 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 23920 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 5 + i32.const 23952 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 24736 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + i32.const 6 + i32.const 24768 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 25360 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/program.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.tee $target + i32.store + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/array/Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end + if + i32.const 480 + i32.const 720 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 + i32.shl + i32.add + local.set $targetStart + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/array/Array#get:dataStart + local.set $sourceStart + i32.const 0 + i32.eqz + drop + local.get $targetStart + local.get $sourceStart + local.get $sourceLen + i32.const 0 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/liftBytes (param $data i32) (result i32) + (local $p i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $p + i32.store offset=4 + local.get $p + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + i32.const 0 + call $~lib/typedarray/Uint8Array#set<~lib/array/Array> + local.get $p + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u24 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 3 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 3 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u16 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 2 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.const 15 + i32.and + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#u32 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 4 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 3 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 24 + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 4 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/codec/Decoder#isExhausted (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#get:offset + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $assembly/codec/Decoder#get:source + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + i32.ge_s + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $assembly/codec/Decoder#finish (param $this i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + i32.const 25696 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $1 + call $assembly/codec/Decoder#get:source + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/codec/Decoder#get:offset + i32.sub + i32.const 10 + call $~lib/number/I32#toString + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/string/String#concat + i32.const 22672 + i32.const 31 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/MemoryBuilder#setEmpty (param $this i32) (param $access i32) (param $address i32) (param $len i32) (result i32) + (local $endAddress i32) + (local $currentAddress i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $address + local.get $len + i32.add + local.set $endAddress + local.get $address + local.set $currentAddress + loop $for-loop|0 + local.get $currentAddress + local.get $endAddress + i32.lt_u + if + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $access + local.get $currentAddress + call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress + drop + local.get $currentAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.add + local.set $currentAddress + br $for-loop|0 + end + end + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/spi/StandardProgram#constructor (param $this i32) (param $program i32) (param $memory i32) (param $registers i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 47 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:program + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:memory + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:registers + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:metadata + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/spi/StandardProgram#set:pc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i64.const 0 + call $assembly/spi/StandardProgram#set:gas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/spi/decodeSpi (param $data i32) (param $args i32) (result i32) + (local $argsLength i32) + (local $decoder i32) + (local $roLength i32) + (local $rwLength i32) + (local $heapPages i32) + (local $stackSize i32) + (local $roMem i32) + (local $rwMem i32) + (local $codeLength i32) + (local $code i32) + (local $program i32) + (local $builder i32) + (local $heapStart i32) + (local $heapZerosStart i32) + (local $heapZerosLength i32) + (local $heapZerosEnd i32) + (local $stackLength i32) + (local $stackStart i32) + (local $memory i32) + (local $registers i32) + (local $22 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + local.get $args + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $~lib/typedarray/Uint8Array#get:length + local.set $argsLength + local.get $argsLength + global.get $assembly/spi/DATA_LENGTH + i32.gt_u + if + i32.const 25552 + i32.const 25632 + i32.const 18 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#u24 + local.set $roLength + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#u24 + local.set $rwLength + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#u16 + local.set $heapPages + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#u24 + local.set $stackSize + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + local.get $roLength + call $assembly/codec/Decoder#bytes + local.tee $roMem + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + local.get $rwLength + call $assembly/codec/Decoder#bytes + local.tee $rwMem + i32.store offset=12 + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#u32 + local.set $codeLength + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + local.get $codeLength + call $assembly/codec/Decoder#bytes + local.tee $code + i32.store offset=16 + local.get $decoder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/codec/Decoder#finish + global.get $~lib/memory/__stack_pointer + local.get $code + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + call $assembly/program/deblob + local.tee $program + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store offset=24 + i32.const 2 + global.get $assembly/memory-page/SEGMENT_SIZE + i32.mul + local.get $roLength + call $assembly/spi/alignToSegmentSize + i32.add + local.set $heapStart + local.get $heapStart + local.get $rwLength + call $assembly/spi/alignToPageSize + i32.add + local.set $heapZerosStart + local.get $heapPages + i32.const 65535 + i32.and + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.set $heapZerosLength + local.get $heapZerosStart + local.get $heapZerosLength + i32.add + local.set $heapZerosEnd + local.get $stackSize + call $assembly/spi/alignToPageSize + local.set $stackLength + global.get $assembly/spi/STACK_SEGMENT_END + local.get $stackLength + i32.sub + local.set $stackStart + local.get $roLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + global.get $assembly/memory-page/Access.Read + global.get $assembly/memory-page/SEGMENT_SIZE + local.get $roMem + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store offset=28 + local.get $22 + call $assembly/memory/MemoryBuilder#setData + drop + end + local.get $argsLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + global.get $assembly/memory-page/Access.Read + global.get $assembly/spi/ARGS_SEGMENT_START + local.get $args + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store offset=28 + local.get $22 + call $assembly/memory/MemoryBuilder#setData + drop + end + local.get $rwLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + global.get $assembly/memory-page/Access.Write + local.get $heapStart + local.get $rwMem + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store offset=28 + local.get $22 + call $assembly/memory/MemoryBuilder#setData + drop + end + local.get $heapZerosLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + global.get $assembly/memory-page/Access.Write + local.get $heapZerosStart + local.get $heapZerosLength + call $assembly/memory/MemoryBuilder#setEmpty + drop + end + local.get $stackLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + global.get $assembly/memory-page/Access.Write + local.get $stackStart + local.get $stackLength + call $assembly/memory/MemoryBuilder#setEmpty + drop + end + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + local.get $heapZerosEnd + call $assembly/memory/MemoryBuilder#build + local.tee $memory + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=36 + local.get $registers + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + i32.const 0 + i64.const 4294901760 + call $~lib/staticarray/StaticArray#__set + local.get $registers + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + i32.const 1 + global.get $assembly/spi/STACK_SEGMENT_END + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + local.get $registers + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + i32.const 7 + global.get $assembly/spi/ARGS_SEGMENT_START + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + local.get $registers + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + i32.const 8 + local.get $argsLength + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + i32.const 0 + local.get $program + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store + local.get $22 + local.get $memory + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store offset=28 + local.get $22 + local.get $registers + local.set $22 + global.get $~lib/memory/__stack_pointer + local.get $22 + i32.store offset=40 + local.get $22 + call $assembly/spi/StandardProgram#constructor + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return + ) + (func $assembly/program/Program#toString (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program/Program#get:code + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#toString + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program/Program#get:mask + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program/Mask#toString + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program/Program#get:jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program/JumpTable#toString + local.tee $3 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/program/Program#get:basicBlocks + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/program/BasicBlocks#toString + local.tee $4 + i32.store offset=20 + i32.const 26320 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 1 + local.get $1 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26320 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 3 + local.get $2 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26320 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 5 + local.get $3 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26320 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 7 + local.get $4 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26320 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 4080 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $"~lib/map/Map#get:size" (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $"~lib/map/Map#get:entriesCount" + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $value i64) + (local $sepLen i32) + (local $estLen i32) + (local $result i32) + (local $offset i32) + (local $value|9 i64) + (local $i i32) + (local $11 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s + if + i32.const 4080 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $lastIndex + i32.eqz + if + local.get $dataStart + i64.load + local.set $value + i32.const 0 + drop + i32.const 8 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 10 + call $~lib/util/number/utoa64 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $separator + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + local.set $sepLen + i32.const 20 + local.get $sepLen + i32.add + local.get $lastIndex + i32.mul + i32.const 20 + i32.add + local.set $estLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=4 + i32.const 0 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $lastIndex + i32.lt_s + if + local.get $dataStart + local.get $i + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $sepLen + if + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $separator + local.get $sepLen + i32.const 1 + i32.shl + memory.copy + local.get $offset + local.get $sepLen + i32.add + local.set $offset + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $dataStart + local.get $lastIndex + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $estLen + local.get $offset + i32.gt_s + if + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.const 0 + local.get $offset + call $~lib/string/String#substring + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $~lib/staticarray/StaticArray#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 0 + drop + i32.const 1 + drop + local.get $this + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/staticarray/StaticArray#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/util/string/joinIntegerArray + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/staticarray/StaticArray#toString (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 10000 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/staticarray/StaticArray#join + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $assembly/spi/StandardProgram#toString (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/spi/StandardProgram#get:program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/program/Program#toString + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/spi/StandardProgram#get:memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Memory#get:pages + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $"~lib/map/Map#get:size" + i32.const 10 + call $~lib/number/I32#toString + local.tee $2 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/spi/StandardProgram#get:registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/staticarray/StaticArray#toString + local.tee $3 + i32.store offset=20 + i32.const 26048 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $1 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26048 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 3 + local.get $2 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26048 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 5 + local.get $3 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 26048 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 4080 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/spi.test~anonymous|0 (param $$0 i32) (result i32) + (local $1 i32) + (local $PROGRAM i32) + (local $3 i32) + (local $ARGS i32) + (local $spi i32) + (local $assert i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 36 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 0 + i32.const 34 + i32.const 25472 + call $~lib/rt/__newArray + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $assembly/program/liftBytes + local.tee $PROGRAM + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 3 + i32.const 0 + i32.const 34 + i32.const 25520 + call $~lib/rt/__newArray + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $assembly/program/liftBytes + local.tee $ARGS + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $PROGRAM + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $ARGS + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/spi/decodeSpi + local.tee $spi + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.tee $assert + i32.store offset=20 + local.get $assert + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $spi + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=32 + local.get $7 + call $assembly/spi/StandardProgram#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + i32.const 26384 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=24 + local.get $7 + i32.const 4080 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=28 + local.get $7 + call $assembly/test/Assert#isEqual<~lib/string/String> + local.get $assert + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $start:assembly/spi.test + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + call $start:assembly/spi + global.get $~lib/memory/__stack_pointer + i32.const 1 + i32.const 2 + i32.const 23 + i32.const 0 + call $~lib/rt/__newArray + local.tee $0 + i32.store + local.get $0 + i32.const 0 + i32.const 25392 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 26864 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/test/test + call $~lib/array/Array#__set + local.get $0 + global.set $assembly/spi.test/TESTS + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 21616 + i32.const 1888 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array<~lib/string/String>#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array<~lib/string/String>#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array<~lib/string/String>#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<~lib/string/String>#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 1888 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 21616 + i32.const 1888 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/test-run/printSummary (param $msg i32) (param $okay i32) (param $total i32) + (local $ico i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $okay + local.get $total + i32.eq + if (result i32) + i32.const 27216 + else + i32.const 27248 + end + local.tee $ico + i32.store + global.get $~lib/memory/__stack_pointer + local.get $msg + local.tee $4 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $okay + i32.const 10 + call $~lib/number/U32#toString + local.tee $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $total + i32.const 10 + call $~lib/number/U32#toString + local.tee $6 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $ico + local.tee $7 + i32.store offset=20 + i32.const 27344 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 0 + local.get $4 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27344 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 2 + local.get $5 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27344 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 4 + local.get $6 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27344 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 6 + local.get $7 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27344 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=24 + local.get $8 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=28 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/test-run/run (param $tests i32) (param $file i32) (result i64) + (local $ok i32) + (local $i i32) + (local $res i32) + (local $5 i32) + (local $j i32) + (local $7 i32) + (local $8 i32) + (local $9 i64) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + i32.const 0 + local.set $ok + i32.const 26928 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $file + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/console/console.log + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/array/Array#get:length + i32.lt_s + if + i32.const 26960 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + local.get $i + call $~lib/array/Array#__get + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $assembly/test/Test#get:name + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/test/Assert#constructor + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + global.set $~argumentsLength + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + local.get $i + call $~lib/array/Array#__get + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/test/Test#get:ptr + i32.load + call_indirect (type $0) + local.tee $res + i32.store offset=20 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/test/Assert#get:isOkay + if + global.get $~lib/memory/__stack_pointer + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + local.get $i + call $~lib/array/Array#__get + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/test/Test#get:name + local.tee $5 + i32.store offset=24 + i32.const 27056 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 1 + local.get $5 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27056 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/console/console.log + local.get $ok + i32.const 1 + i32.add + local.set $ok + else + i32.const 0 + local.set $j + loop $for-loop|1 + local.get $j + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/test/Assert#get:errors + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/array/Array<~lib/string/String>#get:length + i32.lt_s + if + i32.const 27088 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $assembly/test/Assert#get:errors + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + local.get $j + call $~lib/array/Array<~lib/string/String>#__get + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/console/console.log + local.get $j + i32.const 1 + i32.add + local.set $j + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + local.get $i + call $~lib/array/Array#__get + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/test/Test#get:name + local.tee $7 + i32.store offset=28 + i32.const 27152 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 1 + local.get $7 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 27152 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 4080 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/console/console.log + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 27184 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $file + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/string/String#concat + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $ok + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $~lib/array/Array#get:length + call $assembly/test-run/printSummary + local.get $ok + i64.extend_i32_s + i64.const 32 + i64.shl + local.get $tests + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/array/Array#get:length + i64.extend_i32_s + i64.add + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $assembly/test-run/runAllTests + (local $a i64) + (local $okay i32) + (local $total i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i64.const 0 + local.set $a + local.get $a + global.get $assembly/instructions/bit.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 26896 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/instructions/branch.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27392 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/instructions/logic.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27440 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/instructions/math.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27488 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/memory.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27536 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/program.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27584 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/instructions/rot.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27632 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + global.get $assembly/spi.test/TESTS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 27664 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/test-run/run + i64.add + local.set $a + local.get $a + i64.const 32 + i64.shr_u + i32.wrap_i64 + local.set $okay + local.get $a + i32.wrap_i64 + local.set $total + i32.const 27696 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $okay + local.get $total + call $assembly/test-run/printSummary + local.get $okay + local.get $total + i32.ne + if + i32.const 27744 + i32.const 27808 + i32.const 28 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#__visit" (param $this i32) (param $cookie i32) + (local $entries i32) + (local $cur i32) + (local $end i32) + (local $entry i32) + (local $val i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:buckets" + local.get $cookie + call $~lib/rt/itcms/__visit + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:entries" + local.set $entries + i32.const 1 + drop + local.get $entries + local.set $cur + local.get $cur + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.6" + end + i32.mul + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + i32.const 0 + drop + i32.const 1 + drop + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $val + i32.const 0 + drop + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.7" + end + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $entries + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<~lib/string/String>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 1 + drop + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28u8%29=>u8>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28u8%29=>u8>#get:_env + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/object/Object#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 3 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1408 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 3 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 13 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/arraybuffer/ArrayBuffer#constructor (param $this i32) (param $length i32) (result i32) + (local $buffer i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.gt_u + if + i32.const 1296 + i32.const 1344 + i32.const 52 + i32.const 43 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $buffer + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/rt/__newArray (param $length i32) (param $alignLog2 i32) (param $id i32) (param $data i32) (result i32) + (local $bufferSize i32) + (local $buffer i32) + (local $array i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + local.get $alignLog2 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + local.get $data + call $~lib/rt/__newBuffer + local.tee $buffer + i32.store + i32.const 16 + local.get $id + call $~lib/rt/itcms/__new + local.set $array + local.get $array + local.get $buffer + i32.store + local.get $array + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + local.get $array + local.get $buffer + i32.store offset=4 + local.get $array + local.get $bufferSize + i32.store offset=8 + local.get $array + local.get $length + i32.store offset=12 + local.get $array + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $~lib/util/number/itoa32 (param $value i32) (param $radix i32) (result i32) + (local $sign i32) + (local $out i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|8 i32) + (local $buffer|9 i32) + (local $num|10 i32) + (local $offset|11 i32) + (local $val32 i32) + (local $decimals|13 i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 2304 + i32.const 2432 + i32.const 373 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i32.eqz + if + i32.const 2496 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $value + i32.const 31 + i32.shr_u + i32.const 1 + i32.shl + local.set $sign + local.get $sign + if + i32.const 0 + local.get $value + i32.sub + local.set $value + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer + local.get $value + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 31 + local.get $value + i32.clz + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|8 + global.get $~lib/memory/__stack_pointer + local.get $decimals|8 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|9 + local.get $value + local.set $num|10 + local.get $decimals|8 + local.set $offset|11 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|9 + local.get $num|10 + i64.extend_i32_u + local.get $offset|11 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.set $val32 + local.get $val32 + i64.extend_i32_u + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|13 + global.get $~lib/memory/__stack_pointer + local.get $decimals|13 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.get $val32 + i64.extend_i32_u + local.get $decimals|13 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $sign + if + local.get $out + i32.const 45 + i32.store16 + end + local.get $out + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + ) + (func $~lib/util/number/utoa64 (param $value i64) (param $radix i32) (result i32) + (local $out i32) + (local $val32 i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|8 i32) + (local $buffer|9 i32) + (local $num|10 i64) + (local $offset|11 i32) + (local $decimals|12 i32) + (local $buffer|13 i32) + (local $num|14 i64) + (local $offset|15 i32) + (local $decimals|16 i32) + (local $17 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 2304 + i32.const 2432 + i32.const 401 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i64.const 0 + i64.ne + i32.eqz + if + i32.const 2496 + local.set $17 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $17 + return + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + call $~lib/util/number/decimalCount64High + local.set $decimals|8 + global.get $~lib/memory/__stack_pointer + local.get $decimals|8 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|9 + local.get $value + local.set $num|10 + local.get $decimals|8 + local.set $offset|11 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|9 + local.get $num|10 + local.get $offset|11 + call $~lib/util/number/utoa64_dec_lut + end + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 63 + local.get $value + i64.clz + i32.wrap_i64 + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|12 + global.get $~lib/memory/__stack_pointer + local.get $decimals|12 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|13 + local.get $value + local.set $num|14 + local.get $decimals|12 + local.set $offset|15 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|13 + local.get $num|14 + local.get $offset|15 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|16 + global.get $~lib/memory/__stack_pointer + local.get $decimals|16 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $value + local.get $decimals|16 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $out + local.set $17 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $17 + return + ) + (func $~lib/util/number/itoa64 (param $value i64) (param $radix i32) (result i32) + (local $sign i32) + (local $out i32) + (local $val32 i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|9 i32) + (local $buffer|10 i32) + (local $num|11 i64) + (local $offset|12 i32) + (local $decimals|13 i32) + (local $buffer|14 i32) + (local $num|15 i64) + (local $offset|16 i32) + (local $decimals|17 i32) + (local $18 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 2304 + i32.const 2432 + i32.const 431 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i64.const 0 + i64.ne + i32.eqz + if + i32.const 2496 + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + end + local.get $value + i64.const 63 + i64.shr_u + i32.wrap_i64 + i32.const 1 + i32.shl + local.set $sign + local.get $sign + if + i64.const 0 + local.get $value + i64.sub + local.set $value + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + call $~lib/util/number/decimalCount64High + local.set $decimals|9 + global.get $~lib/memory/__stack_pointer + local.get $decimals|9 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|10 + local.get $value + local.set $num|11 + local.get $decimals|9 + local.set $offset|12 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|10 + local.get $num|11 + local.get $offset|12 + call $~lib/util/number/utoa64_dec_lut + end + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 63 + local.get $value + i64.clz + i32.wrap_i64 + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|13 + global.get $~lib/memory/__stack_pointer + local.get $decimals|13 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.set $buffer|14 + local.get $value + local.set $num|15 + local.get $decimals|13 + local.set $offset|16 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|14 + local.get $num|15 + local.get $offset|16 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|17 + global.get $~lib/memory/__stack_pointer + local.get $decimals|17 + i32.const 1 + i32.shl + local.get $sign + i32.add + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $sign + i32.add + local.get $value + local.get $decimals|17 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $sign + if + local.get $out + i32.const 45 + i32.store16 + end + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $18 + return + ) + (func $~lib/util/number/utoa32 (param $value i32) (param $radix i32) (result i32) + (local $out i32) + (local $decimals i32) + (local $buffer i32) + (local $num i32) + (local $offset i32) + (local $decimals|7 i32) + (local $buffer|8 i32) + (local $num|9 i32) + (local $offset|10 i32) + (local $decimals|11 i32) + (local $12 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $radix + i32.const 2 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $radix + i32.const 36 + i32.gt_s + end + if + i32.const 2304 + i32.const 2432 + i32.const 350 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $value + i32.eqz + if + i32.const 2496 + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + end + local.get $radix + i32.const 10 + i32.eq + if + local.get $value + call $~lib/util/number/decimalCount32 + local.set $decimals + global.get $~lib/memory/__stack_pointer + local.get $decimals + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer + local.get $value + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $radix + i32.const 16 + i32.eq + if + i32.const 31 + local.get $value + i32.clz + i32.sub + i32.const 2 + i32.shr_s + i32.const 1 + i32.add + local.set $decimals|7 + global.get $~lib/memory/__stack_pointer + local.get $decimals|7 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.set $buffer|8 + local.get $value + local.set $num|9 + local.get $decimals|7 + local.set $offset|10 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|8 + local.get $num|9 + i64.extend_i32_u + local.get $offset|10 + call $~lib/util/number/utoa_hex_lut + else + local.get $value + i64.extend_i32_u + local.get $radix + call $~lib/util/number/ulog_base + local.set $decimals|11 + global.get $~lib/memory/__stack_pointer + local.get $decimals|11 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + local.get $out + local.get $value + i64.extend_i32_u + local.get $decimals|11 + local.get $radix + call $~lib/util/number/utoa64_any_core + end + end + local.get $out + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $12 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 0 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1408 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 0 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 29 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1408 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 2 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 38 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 1296 + i32.const 1408 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 2 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 44 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) +) From af084ff66496d7edc368ffccda37b330ed6e5b41 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Mon, 13 Oct 2025 18:47:58 +0200 Subject: [PATCH 03/21] deleted dist --- dist/debug.d.ts | 182 - dist/debug.js | 372 - dist/debug.wasm | Bin 186138 -> 0 bytes dist/debug.wasm.map | 1 - dist/debug.wat | 45256 --------------------------------------- dist/release.d.ts | 182 - dist/release.js | 372 - dist/release.wasm | Bin 93361 -> 0 bytes dist/release.wasm.map | 1 - dist/release.wat | 36780 -------------------------------- dist/test.d.ts | 6 - dist/test.js | 47 - dist/test.wasm | Bin 189597 -> 0 bytes dist/test.wasm.map | 1 - dist/test.wat | 45369 ---------------------------------------- 15 files changed, 128569 deletions(-) delete mode 100644 dist/debug.d.ts delete mode 100644 dist/debug.js delete mode 100644 dist/debug.wasm delete mode 100644 dist/debug.wasm.map delete mode 100644 dist/debug.wat delete mode 100644 dist/release.d.ts delete mode 100644 dist/release.js delete mode 100644 dist/release.wasm delete mode 100644 dist/release.wasm.map delete mode 100644 dist/release.wat delete mode 100644 dist/test.d.ts delete mode 100644 dist/test.js delete mode 100644 dist/test.wasm delete mode 100644 dist/test.wasm.map delete mode 100644 dist/test.wat diff --git a/dist/debug.d.ts b/dist/debug.d.ts deleted file mode 100644 index 97c330c..0000000 --- a/dist/debug.d.ts +++ /dev/null @@ -1,182 +0,0 @@ -/** Exported memory */ -export declare const memory: WebAssembly.Memory; -/** assembly/index/InputKind */ -export declare enum InputKind { - /** @type `i32` */ - Generic, - /** @type `i32` */ - SPI, -} -/** assembly/index/HasMetadata */ -export declare enum HasMetadata { - /** @type `i32` */ - Yes, - /** @type `i32` */ - No, -} -/** - * assembly/index/disassemble - * @param input `~lib/array/Array` - * @param kind `i32` - * @param withMetadata `i32` - * @returns `~lib/string/String` - */ -export declare function disassemble(input: Array, kind: number, withMetadata: number): string; -/** - * assembly/index/runProgram - * @param input `~lib/array/Array` - * @param registers `~lib/array/Array` - * @param kind `i32` - * @returns `assembly/api-generic/VmOutput` - */ -export declare function runProgram(input: Array, registers: Array, kind: number): __Record44; -/** - * assembly/api-generic/runVm - * @param input `assembly/api-generic/VmInput` - * @param logs `bool` - * @param useSbrkGas `bool` - * @returns `assembly/api-generic/VmOutput` - */ -export declare function runVm(input: __Record47, logs?: boolean, useSbrkGas?: boolean): __Record44; -/** - * assembly/api-generic/getAssembly - * @param p `assembly/program/Program` - * @returns `~lib/string/String` - */ -export declare function getAssembly(p: __Internref30): string; -/** - * assembly/program-build/wrapAsProgram - * @param bytecode `~lib/typedarray/Uint8Array` - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array; -/** - * assembly/api/resetGeneric - * @param program `~lib/array/Array` - * @param flatRegisters `~lib/array/Array` - * @param initialGas `i64` - */ -export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint): void; -/** - * assembly/api/resetGenericWithMemory - * @param program `~lib/array/Array` - * @param flatRegisters `~lib/array/Array` - * @param pageMap `~lib/typedarray/Uint8Array` - * @param chunks `~lib/typedarray/Uint8Array` - * @param initialGas `i64` - */ -export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint): void; -/** - * assembly/api/nextStep - * @returns `bool` - */ -export declare function nextStep(): boolean; -/** - * assembly/api/nSteps - * @param steps `u32` - * @returns `bool` - */ -export declare function nSteps(steps: number): boolean; -/** - * assembly/api/getProgramCounter - * @returns `u32` - */ -export declare function getProgramCounter(): number; -/** - * assembly/api/setNextProgramCounter - * @param pc `u32` - */ -export declare function setNextProgramCounter(pc: number): void; -/** - * assembly/api/getStatus - * @returns `u8` - */ -export declare function getStatus(): number; -/** - * assembly/api/getExitArg - * @returns `u32` - */ -export declare function getExitArg(): number; -/** - * assembly/api/getGasLeft - * @returns `i64` - */ -export declare function getGasLeft(): bigint; -/** - * assembly/api/setGasLeft - * @param gas `i64` - */ -export declare function setGasLeft(gas: bigint): void; -/** - * assembly/api/getRegisters - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function getRegisters(): Uint8Array; -/** - * assembly/api/setRegisters - * @param flatRegisters `~lib/array/Array` - */ -export declare function setRegisters(flatRegisters: Array): void; -/** - * assembly/api/getPageDump - * @param index `u32` - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function getPageDump(index: number): Uint8Array; -/** - * assembly/api/setMemory - * @param address `u32` - * @param data `~lib/typedarray/Uint8Array` - */ -export declare function setMemory(address: number, data: Uint8Array): void; -/** assembly/api-generic/InitialChunk */ -declare interface __Record45 { - /** @type `u32` */ - address: number | TOmittable; - /** @type `~lib/array/Array` */ - data: Array; -} -/** assembly/api-generic/VmOutput */ -declare interface __Record44 { - /** @type `i32` */ - status: number | TOmittable; - /** @type `~lib/array/Array` */ - registers: Array; - /** @type `u32` */ - pc: number | TOmittable; - /** @type `~lib/array/Array` */ - memory: Array<__Record45>; - /** @type `i64` */ - gas: bigint | TOmittable; - /** @type `u32` */ - exitCode: number | TOmittable; -} -/** assembly/api-generic/InitialPage */ -declare interface __Record48 { - /** @type `u32` */ - address: number | TOmittable; - /** @type `u32` */ - length: number | TOmittable; - /** @type `i32` */ - access: number | TOmittable; -} -/** assembly/api-generic/VmInput */ -declare interface __Record47 { - /** @type `~lib/array/Array` */ - registers: Array; - /** @type `u32` */ - pc: number | TOmittable; - /** @type `i64` */ - gas: bigint | TOmittable; - /** @type `~lib/array/Array` */ - program: Array; - /** @type `~lib/array/Array` */ - pageMap: Array<__Record48>; - /** @type `~lib/array/Array` */ - memory: Array<__Record45>; -} -/** assembly/program/Program */ -declare class __Internref30 extends Number { - private __nominal30: symbol; - private __nominal0: symbol; -} diff --git a/dist/debug.js b/dist/debug.js deleted file mode 100644 index 1fc85df..0000000 --- a/dist/debug.js +++ /dev/null @@ -1,372 +0,0 @@ -async function instantiate(module, imports = {}) { - const adaptedImports = { - env: Object.setPrototypeOf({ - abort(message, fileName, lineNumber, columnNumber) { - // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void - message = __liftString(message >>> 0); - fileName = __liftString(fileName >>> 0); - lineNumber = lineNumber >>> 0; - columnNumber = columnNumber >>> 0; - (() => { - // @external.js - throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); - })(); - }, - "console.log"(text) { - // ~lib/bindings/dom/console.log(~lib/string/String) => void - text = __liftString(text >>> 0); - console.log(text); - }, - }, Object.assign(Object.create(globalThis), imports.env || {})), - }; - const { exports } = await WebAssembly.instantiate(module, adaptedImports); - const memory = exports.memory || imports.env.memory; - const adaptedExports = Object.setPrototypeOf({ - InputKind: (values => ( - // assembly/index/InputKind - values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", - values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", - values - ))({}), - HasMetadata: (values => ( - // assembly/index/HasMetadata - values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", - values[values.No = exports["HasMetadata.No"].valueOf()] = "No", - values - ))({}), - disassemble(input, kind, withMetadata) { - // assembly/index/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String - input = __lowerArray(__setU8, 27, 0, input) || __notnull(); - return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); - }, - runProgram(input, registers, kind) { - // assembly/index/runProgram(~lib/array/Array, ~lib/array/Array, i32) => assembly/api-generic/VmOutput - input = __retain(__lowerArray(__setU8, 27, 0, input) || __notnull()); - registers = __lowerArray(__setU64, 43, 3, registers) || __notnull(); - try { - return __liftRecord44(exports.runProgram(input, registers, kind) >>> 0); - } finally { - __release(input); - } - }, - runVm(input, logs, useSbrkGas) { - // assembly/api-generic/runVm(assembly/api-generic/VmInput, bool?, bool?) => assembly/api-generic/VmOutput - input = __lowerRecord47(input) || __notnull(); - logs = logs ? 1 : 0; - useSbrkGas = useSbrkGas ? 1 : 0; - exports.__setArgumentsLength(arguments.length); - return __liftRecord44(exports.runVm(input, logs, useSbrkGas) >>> 0); - }, - getAssembly(p) { - // assembly/api-generic/getAssembly(assembly/program/Program) => ~lib/string/String - p = __lowerInternref(p) || __notnull(); - return __liftString(exports.getAssembly(p) >>> 0); - }, - wrapAsProgram(bytecode) { - // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array - bytecode = __lowerTypedArray(Uint8Array, 5, 0, bytecode) || __notnull(); - return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0); - }, - resetGeneric(program, flatRegisters, initialGas) { - // assembly/api/resetGeneric(~lib/array/Array, ~lib/array/Array, i64) => void - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); - initialGas = initialGas || 0n; - try { - exports.resetGeneric(program, flatRegisters, initialGas); - } finally { - __release(program); - } - }, - resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas) { - // assembly/api/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64) => void - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - flatRegisters = __retain(__lowerArray(__setU8, 27, 0, flatRegisters) || __notnull()); - pageMap = __retain(__lowerTypedArray(Uint8Array, 5, 0, pageMap) || __notnull()); - chunks = __lowerTypedArray(Uint8Array, 5, 0, chunks) || __notnull(); - initialGas = initialGas || 0n; - try { - exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas); - } finally { - __release(program); - __release(flatRegisters); - __release(pageMap); - } - }, - nextStep() { - // assembly/api/nextStep() => bool - return exports.nextStep() != 0; - }, - nSteps(steps) { - // assembly/api/nSteps(u32) => bool - return exports.nSteps(steps) != 0; - }, - getProgramCounter() { - // assembly/api/getProgramCounter() => u32 - return exports.getProgramCounter() >>> 0; - }, - getExitArg() { - // assembly/api/getExitArg() => u32 - return exports.getExitArg() >>> 0; - }, - setGasLeft(gas) { - // assembly/api/setGasLeft(i64) => void - gas = gas || 0n; - exports.setGasLeft(gas); - }, - getRegisters() { - // assembly/api/getRegisters() => ~lib/typedarray/Uint8Array - return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); - }, - setRegisters(flatRegisters) { - // assembly/api/setRegisters(~lib/array/Array) => void - flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); - exports.setRegisters(flatRegisters); - }, - getPageDump(index) { - // assembly/api/getPageDump(u32) => ~lib/typedarray/Uint8Array - return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); - }, - setMemory(address, data) { - // assembly/api/setMemory(u32, ~lib/typedarray/Uint8Array) => void - data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); - exports.setMemory(address, data); - }, - }, exports); - function __liftRecord45(pointer) { - // assembly/api-generic/InitialChunk - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - address: __getU32(pointer + 0), - data: __liftArray(__getU8, 0, __getU32(pointer + 4)), - }; - } - function __liftRecord44(pointer) { - // assembly/api-generic/VmOutput - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - status: __getI32(pointer + 0), - registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), - pc: __getU32(pointer + 8), - memory: __liftArray(pointer => __liftRecord45(__getU32(pointer)), 2, __getU32(pointer + 12)), - gas: __getI64(pointer + 16), - exitCode: __getU32(pointer + 24), - }; - } - function __lowerRecord48(value) { - // assembly/api-generic/InitialPage - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(12, 48)); - __setU32(pointer + 0, value.address); - __setU32(pointer + 4, value.length); - __setU32(pointer + 8, value.access); - exports.__unpin(pointer); - return pointer; - } - function __lowerRecord45(value) { - // assembly/api-generic/InitialChunk - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(8, 45)); - __setU32(pointer + 0, value.address); - __setU32(pointer + 4, __lowerArray(__setU8, 27, 0, value.data) || __notnull()); - exports.__unpin(pointer); - return pointer; - } - function __lowerRecord47(value) { - // assembly/api-generic/VmInput - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(28, 47)); - __setU32(pointer + 0, __lowerArray(__setU64, 43, 3, value.registers) || __notnull()); - __setU32(pointer + 4, value.pc); - __setU64(pointer + 8, value.gas || 0n); - __setU32(pointer + 16, __lowerArray(__setU8, 27, 0, value.program) || __notnull()); - __setU32(pointer + 20, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, value.pageMap) || __notnull()); - __setU32(pointer + 24, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord45(value) || __notnull()); }, 46, 2, value.memory) || __notnull()); - exports.__unpin(pointer); - return pointer; - } - function __liftString(pointer) { - if (!pointer) return null; - const - end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, - memoryU16 = new Uint16Array(memory.buffer); - let - start = pointer >>> 1, - string = ""; - while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); - return string + String.fromCharCode(...memoryU16.subarray(start, end)); - } - function __liftArray(liftElement, align, pointer) { - if (!pointer) return null; - const - dataStart = __getU32(pointer + 4), - length = __dataview.getUint32(pointer + 12, true), - values = new Array(length); - for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0)); - return values; - } - function __lowerArray(lowerElement, id, align, values) { - if (values == null) return 0; - const - length = values.length, - buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, - header = exports.__pin(exports.__new(16, id)) >>> 0; - __setU32(header + 0, buffer); - __dataview.setUint32(header + 4, buffer, true); - __dataview.setUint32(header + 8, length << align, true); - __dataview.setUint32(header + 12, length, true); - for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]); - exports.__unpin(buffer); - exports.__unpin(header); - return header; - } - function __liftTypedArray(constructor, pointer) { - if (!pointer) return null; - return new constructor( - memory.buffer, - __getU32(pointer + 4), - __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT - ).slice(); - } - function __lowerTypedArray(constructor, id, align, values) { - if (values == null) return 0; - const - length = values.length, - buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, - header = exports.__new(12, id) >>> 0; - __setU32(header + 0, buffer); - __dataview.setUint32(header + 4, buffer, true); - __dataview.setUint32(header + 8, length << align, true); - new constructor(memory.buffer, buffer, length).set(values); - exports.__unpin(buffer); - return header; - } - class Internref extends Number {} - function __lowerInternref(value) { - if (value == null) return 0; - if (value instanceof Internref) return value.valueOf(); - throw TypeError("internref expected"); - } - const refcounts = new Map(); - function __retain(pointer) { - if (pointer) { - const refcount = refcounts.get(pointer); - if (refcount) refcounts.set(pointer, refcount + 1); - else refcounts.set(exports.__pin(pointer), 1); - } - return pointer; - } - function __release(pointer) { - if (pointer) { - const refcount = refcounts.get(pointer); - if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer); - else if (refcount) refcounts.set(pointer, refcount - 1); - else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`); - } - } - function __notnull() { - throw TypeError("value must not be null"); - } - let __dataview = new DataView(memory.buffer); - function __setU8(pointer, value) { - try { - __dataview.setUint8(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setUint8(pointer, value, true); - } - } - function __setU32(pointer, value) { - try { - __dataview.setUint32(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setUint32(pointer, value, true); - } - } - function __setU64(pointer, value) { - try { - __dataview.setBigUint64(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setBigUint64(pointer, value, true); - } - } - function __getU8(pointer) { - try { - return __dataview.getUint8(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getUint8(pointer, true); - } - } - function __getI32(pointer) { - try { - return __dataview.getInt32(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getInt32(pointer, true); - } - } - function __getU32(pointer) { - try { - return __dataview.getUint32(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getUint32(pointer, true); - } - } - function __getI64(pointer) { - try { - return __dataview.getBigInt64(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getBigInt64(pointer, true); - } - } - function __getU64(pointer) { - try { - return __dataview.getBigUint64(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getBigUint64(pointer, true); - } - } - return adaptedExports; -} -export const { - memory, - InputKind, - HasMetadata, - disassemble, - runProgram, - runVm, - getAssembly, - wrapAsProgram, - resetGeneric, - resetGenericWithMemory, - nextStep, - nSteps, - getProgramCounter, - setNextProgramCounter, - getStatus, - getExitArg, - getGasLeft, - setGasLeft, - getRegisters, - setRegisters, - getPageDump, - setMemory, -} = await (async url => instantiate( - await (async () => { - const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); - if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } - else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } - })(), { - } -))(new URL("debug.wasm", import.meta.url)); diff --git a/dist/debug.wasm b/dist/debug.wasm deleted file mode 100644 index 3e089c857ddf44378c128c5cd641ae7fb6f281ee..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 186138 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 aTef8Wlxa;psjlI^X{(a?!D)lZq5lJAL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/0a78010a7801?v=0.6.4 **/\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT = 12;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/24ee0024ee00?v=0.6.4 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const pageIdx = u32(currentAddress >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n const relAddress = currentAddress % PAGE_SIZE;\n const page = this.pages.get(pageIdx);\n const spaceInPage = PAGE_SIZE - relAddress;\n\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** https://graypaper.fluffylabs.dev/#/9a08063/2cc5022cc502?v=0.6.6 */\nexport function decodeSpi(data: Uint8Array): Program {\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const _heapPages = decoder.u16();\n const _stackSize = decoder.u24();\n\n const _roMem = decoder.bytes(roLength);\n const _rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n return deblob(code);\n}\n\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { RUN } from \"./instructions-exe\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, JumpTable, Program, ProgramCounter, decodeArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { InitialChunk, InitialPage, buildMemory } from \"./api-generic\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { VmInput, VmOutput, getAssembly, runVm } from \"./api-generic\";\nimport { deblob, decodeSpi, extractCodeAndMetadata, liftBytes } from \"./program\";\n\nexport * from \"./api\";\nexport { runVm, getAssembly } from \"./api-generic\";\nexport { wrapAsProgram } from \"./program-build\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n let program = liftBytes(input);\n let output = \"\";\n\n if (withMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(program);\n program = data.code;\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += data.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n if (kind === InputKind.Generic) {\n const p = deblob(program);\n return output + getAssembly(p);\n }\n\n if (kind === InputKind.SPI) {\n const p = decodeSpi(program);\n return output + getAssembly(p);\n }\n\n return `Unknown kind: ${kind}`;\n}\n\nexport function runProgram(input: u8[], registers: u64[], kind: InputKind): VmOutput {\n if (kind === InputKind.Generic) {\n const vmInput = new VmInput();\n vmInput.registers = registers;\n vmInput.gas = 10_000;\n vmInput.program = input;\n\n const output = runVm(vmInput, true);\n console.log(`Finished with status: ${output.status}`);\n return output;\n }\n\n if (kind === InputKind.SPI) {\n throw new Error(\"SPI running not supported yet\");\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { Program, deblob, decodeArguments, liftBytes, resolveArguments } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n registers: u64[] = new Array(NO_OF_REGISTERS).fill(0);\n pc: u32 = 0;\n gas: i64 = 0;\n program: u8[] = [];\n pageMap: InitialPage[] = [];\n memory: InitialChunk[] = [];\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const p = deblob(liftBytes(input.program));\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < registers.length; r++) {\n registers[r] = input.registers[r];\n }\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, input.pageMap, input.memory);\n\n const int = new Interpreter(p, registers, memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = p.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n return this.gas < 0;\n }\n}\n","import { Arguments, REQUIRED_BYTES, nibbles } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/dist/debug.wat b/dist/debug.wat deleted file mode 100644 index cfbba47..0000000 --- a/dist/debug.wat +++ /dev/null @@ -1,45256 +0,0 @@ -(module - (type $0 (func (param i32) (result i32))) - (type $1 (func (param i32 i32))) - (type $2 (func (param i32 i32 i32) (result i32))) - (type $3 (func (param i32 i32) (result i32))) - (type $4 (func (param i32 i32 i32))) - (type $5 (func (param i32 i32 i32 i32) (result i32))) - (type $6 (func (param i32))) - (type $7 (func)) - (type $8 (func (param i32) (result i64))) - (type $9 (func (param i32 i64))) - (type $10 (func (result i32))) - (type $11 (func (param i64 i64) (result i64))) - (type $12 (func (param i64 i32) (result i32))) - (type $13 (func (param i32 i64) (result i32))) - (type $14 (func (param i64) (result i32))) - (type $15 (func (param i32 i32 i64))) - (type $16 (func (param i32 i32 i32 i32))) - (type $17 (func (param i64 i32 i32) (result i32))) - (type $18 (func (param i32 i32 i64) (result i32))) - (type $19 (func (param i32 i64 i32))) - (type $20 (func (param i32 i32) (result i64))) - (type $21 (func (param i32 i64 i32 i32) (result i32))) - (type $22 (func (param i32 i32 i32 i32 i64))) - (type $23 (func (param i32 i32 i64 i32) (result i32))) - (type $24 (func (param i64) (result i64))) - (type $25 (func (param i32 i32 i32 i32 i32))) - (type $26 (func (param i32 i64 i32 i32))) - (type $27 (func (param i32 i32 i64 i32 i32))) - (type $28 (func (param i32 i32 i32 i32 i32) (result i32))) - (type $29 (func (param i32 i32 i64 i32))) - (type $30 (func (result i64))) - (type $31 (func (param i64))) - (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) - (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) - (global $assembly/arguments/Arguments.Zero i32 (i32.const 0)) - (global $assembly/arguments/Arguments.OneImm i32 (i32.const 1)) - (global $assembly/arguments/Arguments.TwoImm i32 (i32.const 2)) - (global $assembly/arguments/Arguments.OneOff i32 (i32.const 3)) - (global $assembly/arguments/Arguments.OneRegOneImm i32 (i32.const 4)) - (global $assembly/arguments/Arguments.OneRegOneExtImm i32 (i32.const 5)) - (global $assembly/arguments/Arguments.OneRegTwoImm i32 (i32.const 6)) - (global $assembly/arguments/Arguments.OneRegOneImmOneOff i32 (i32.const 7)) - (global $assembly/arguments/Arguments.TwoReg i32 (i32.const 8)) - (global $assembly/arguments/Arguments.TwoRegOneImm i32 (i32.const 9)) - (global $assembly/arguments/Arguments.TwoRegOneOff i32 (i32.const 10)) - (global $assembly/arguments/Arguments.TwoRegTwoImm i32 (i32.const 11)) - (global $assembly/arguments/Arguments.ThreeReg i32 (i32.const 12)) - (global $assembly/arguments/RELEVANT_ARGS i32 (i32.const 112)) - (global $assembly/arguments/REQUIRED_BYTES i32 (i32.const 240)) - (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) - (global $~lib/shared/runtime/Runtime.Stub i32 (i32.const 0)) - (global $~lib/shared/runtime/Runtime.Minimal i32 (i32.const 1)) - (global $~lib/shared/runtime/Runtime.Incremental i32 (i32.const 2)) - (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) - (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) - (global $~lib/native/ASC_LOW_MEMORY_LIMIT i32 (i32.const 0)) - (global $~lib/builtins/i32.MAX_VALUE i32 (i32.const 2147483647)) - (global $~argumentsLength (mut i32) (i32.const 0)) - (global $assembly/arguments/DECODERS i32 (i32.const 1248)) - (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) - (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) - (global $~lib/native/ASC_RUNTIME i32 (i32.const 2)) - (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) - (global $assembly/registers/NO_OF_REGISTERS i32 (i32.const 13)) - (global $assembly/registers/REG_SIZE_BYTES i32 (i32.const 8)) - (global $assembly/memory-page/PAGE_SIZE i32 (i32.const 4096)) - (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) - (global $~lib/native/ASC_SHRINK_LEVEL i32 (i32.const 0)) - (global $assembly/memory-page/RESERVED_MEMORY (mut i32) (i32.const 0)) - (global $assembly/memory-page/RESERVED_PAGES (mut i32) (i32.const 0)) - (global $assembly/memory-page/ALLOCATE_EAGERLY (mut i32) (i32.const 0)) - (global $assembly/memory-page/Access.None i32 (i32.const 0)) - (global $assembly/memory-page/Access.Read i32 (i32.const 1)) - (global $assembly/memory-page/Access.Write i32 (i32.const 2)) - (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) - (global $assembly/memory/MEMORY_SIZE i64 (i64.const 4294967296)) - (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) - (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) - (global $assembly/instructions/outcome/Result.PANIC i32 (i32.const 0)) - (global $assembly/instructions/outcome/Result.FAULT i32 (i32.const 1)) - (global $assembly/instructions/outcome/Result.FAULT_ACCESS i32 (i32.const 2)) - (global $assembly/instructions/outcome/Result.HOST i32 (i32.const 3)) - (global $assembly/instructions/outcome/Outcome.Ok i32 (i32.const 0)) - (global $assembly/instructions/outcome/Outcome.StaticJump i32 (i32.const 1)) - (global $assembly/instructions/outcome/Outcome.DynamicJump i32 (i32.const 2)) - (global $assembly/instructions/outcome/Outcome.Result i32 (i32.const 3)) - (global $assembly/instructions/bit/count_set_bits_64 i32 (i32.const 8352)) - (global $assembly/instructions/bit/count_set_bits_32 i32 (i32.const 8384)) - (global $assembly/instructions/bit/leading_zero_bits_64 i32 (i32.const 8416)) - (global $assembly/instructions/bit/leading_zero_bits_32 i32 (i32.const 8448)) - (global $assembly/instructions/bit/trailing_zero_bits_64 i32 (i32.const 8480)) - (global $assembly/instructions/bit/trailing_zero_bits_32 i32 (i32.const 8512)) - (global $assembly/instructions/bit/sign_extend_8 i32 (i32.const 8544)) - (global $assembly/instructions/bit/sign_extend_16 i32 (i32.const 8576)) - (global $assembly/instructions/bit/zero_extend_16 i32 (i32.const 8608)) - (global $assembly/instructions/bit/reverse_bytes i32 (i32.const 8640)) - (global $assembly/instructions/branch/branch_eq_imm i32 (i32.const 8672)) - (global $assembly/instructions/branch/branch_ne_imm i32 (i32.const 8704)) - (global $assembly/instructions/branch/branch_lt_u_imm i32 (i32.const 8736)) - (global $assembly/instructions/branch/branch_le_u_imm i32 (i32.const 8768)) - (global $assembly/instructions/branch/branch_ge_u_imm i32 (i32.const 8800)) - (global $assembly/instructions/branch/branch_gt_u_imm i32 (i32.const 8832)) - (global $assembly/instructions/branch/branch_lt_s_imm i32 (i32.const 8864)) - (global $assembly/instructions/branch/branch_le_s_imm i32 (i32.const 8896)) - (global $assembly/instructions/branch/branch_ge_s_imm i32 (i32.const 8928)) - (global $assembly/instructions/branch/branch_gt_s_imm i32 (i32.const 8960)) - (global $assembly/instructions/branch/branch_eq i32 (i32.const 8992)) - (global $assembly/instructions/branch/branch_ne i32 (i32.const 9024)) - (global $assembly/instructions/branch/branch_lt_u i32 (i32.const 9056)) - (global $assembly/instructions/branch/branch_lt_s i32 (i32.const 9088)) - (global $assembly/instructions/branch/branch_ge_u i32 (i32.const 9120)) - (global $assembly/instructions/branch/branch_ge_s i32 (i32.const 9152)) - (global $assembly/instructions/jump/jump i32 (i32.const 9184)) - (global $assembly/instructions/jump/jump_ind i32 (i32.const 9216)) - (global $assembly/instructions/jump/load_imm_jump i32 (i32.const 9248)) - (global $assembly/instructions/jump/load_imm_jump_ind i32 (i32.const 9280)) - (global $assembly/instructions/load/load_imm_64 i32 (i32.const 9312)) - (global $assembly/instructions/load/load_imm i32 (i32.const 9344)) - (global $assembly/instructions/load/load_u8 i32 (i32.const 9696)) - (global $assembly/instructions/load/load_i8 i32 (i32.const 9728)) - (global $assembly/instructions/load/load_u16 i32 (i32.const 9760)) - (global $assembly/instructions/load/load_i16 i32 (i32.const 9792)) - (global $assembly/instructions/load/load_u32 i32 (i32.const 9824)) - (global $assembly/instructions/load/load_i32 i32 (i32.const 9856)) - (global $assembly/instructions/load/load_u64 i32 (i32.const 9888)) - (global $assembly/instructions/load/load_ind_u8 i32 (i32.const 9920)) - (global $assembly/instructions/load/load_ind_i8 i32 (i32.const 9952)) - (global $assembly/instructions/load/load_ind_u16 i32 (i32.const 9984)) - (global $assembly/instructions/load/load_ind_i16 i32 (i32.const 10016)) - (global $assembly/instructions/load/load_ind_u32 i32 (i32.const 10048)) - (global $assembly/instructions/load/load_ind_i32 i32 (i32.const 10080)) - (global $assembly/instructions/load/load_ind_u64 i32 (i32.const 10112)) - (global $assembly/instructions/logic/and_imm i32 (i32.const 10144)) - (global $assembly/instructions/logic/xor_imm i32 (i32.const 10176)) - (global $assembly/instructions/logic/or_imm i32 (i32.const 10208)) - (global $assembly/instructions/logic/and i32 (i32.const 10240)) - (global $assembly/instructions/logic/xor i32 (i32.const 10272)) - (global $assembly/instructions/logic/or i32 (i32.const 10304)) - (global $assembly/instructions/logic/and_inv i32 (i32.const 10336)) - (global $assembly/instructions/logic/or_inv i32 (i32.const 10368)) - (global $assembly/instructions/logic/xnor i32 (i32.const 10400)) - (global $assembly/instructions/math/add_imm_32 i32 (i32.const 10432)) - (global $assembly/instructions/math/mul_imm_32 i32 (i32.const 10464)) - (global $assembly/instructions/math/neg_add_imm_32 i32 (i32.const 10496)) - (global $assembly/instructions/math/add_imm i32 (i32.const 10528)) - (global $assembly/instructions/math/mul_imm i32 (i32.const 10560)) - (global $assembly/instructions/math/neg_add_imm i32 (i32.const 10592)) - (global $assembly/instructions/math/add_32 i32 (i32.const 10624)) - (global $assembly/instructions/math/sub_32 i32 (i32.const 10656)) - (global $assembly/instructions/math/mul_32 i32 (i32.const 10688)) - (global $~lib/builtins/u64.MAX_VALUE i64 (i64.const -1)) - (global $assembly/instructions/math/div_u_32 i32 (i32.const 10720)) - (global $~lib/builtins/i32.MIN_VALUE i32 (i32.const -2147483648)) - (global $assembly/instructions/math/div_s_32 i32 (i32.const 10752)) - (global $assembly/instructions/math/rem_u_32 i32 (i32.const 10784)) - (global $assembly/instructions/math/rem_s_32 i32 (i32.const 10816)) - (global $assembly/instructions/math/add_64 i32 (i32.const 10848)) - (global $assembly/instructions/math/sub i32 (i32.const 10880)) - (global $assembly/instructions/math/mul i32 (i32.const 10912)) - (global $assembly/instructions/math/div_u i32 (i32.const 10944)) - (global $~lib/builtins/i64.MIN_VALUE i64 (i64.const -9223372036854775808)) - (global $assembly/instructions/math/div_s i32 (i32.const 10976)) - (global $assembly/instructions/math/rem_u i32 (i32.const 11008)) - (global $assembly/instructions/math/rem_s i32 (i32.const 11040)) - (global $assembly/instructions/math/mul_upper_s_s i32 (i32.const 11072)) - (global $assembly/instructions/math/mul_upper_u_u i32 (i32.const 11104)) - (global $assembly/instructions/math/mul_upper_s_u i32 (i32.const 11136)) - (global $assembly/instructions/math/max i32 (i32.const 11168)) - (global $assembly/instructions/math/max_u i32 (i32.const 11200)) - (global $assembly/instructions/math/min i32 (i32.const 11232)) - (global $assembly/instructions/math/min_u i32 (i32.const 11264)) - (global $assembly/instructions/mov/move_reg i32 (i32.const 11296)) - (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11328)) - (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11360)) - (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11392)) - (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11424)) - (global $assembly/instructions/rot/rot_r_64_imm i32 (i32.const 11456)) - (global $assembly/instructions/rot/rot_r_64_imm_alt i32 (i32.const 11488)) - (global $assembly/instructions/rot/rot_r_32_imm i32 (i32.const 11520)) - (global $assembly/instructions/rot/rot_r_32_imm_alt i32 (i32.const 11552)) - (global $assembly/instructions/rot/rot_l_64 i32 (i32.const 11584)) - (global $assembly/instructions/rot/rot_l_32 i32 (i32.const 11616)) - (global $assembly/instructions/rot/rot_r_64 i32 (i32.const 11648)) - (global $assembly/instructions/rot/rot_r_32 i32 (i32.const 11680)) - (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 11712)) - (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 11744)) - (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 11776)) - (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 11808)) - (global $assembly/instructions/set/set_lt_u i32 (i32.const 11840)) - (global $assembly/instructions/set/set_lt_s i32 (i32.const 11872)) - (global $assembly/instructions/shift/MAX_SHIFT_64 i32 (i32.const 64)) - (global $assembly/instructions/shift/MAX_SHIFT_32 i32 (i32.const 32)) - (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 11904)) - (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 11936)) - (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 11968)) - (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 12000)) - (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 12032)) - (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 12064)) - (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 12096)) - (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 12128)) - (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 12160)) - (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 12192)) - (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 12224)) - (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 12256)) - (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 12288)) - (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 12320)) - (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12352)) - (global $assembly/instructions/shift/shlo_l i32 (i32.const 12384)) - (global $assembly/instructions/shift/shlo_r i32 (i32.const 12416)) - (global $assembly/instructions/shift/shar_r i32 (i32.const 12448)) - (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12480)) - (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12512)) - (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12544)) - (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12576)) - (global $assembly/instructions/store/store_u8 i32 (i32.const 12608)) - (global $assembly/instructions/store/store_u16 i32 (i32.const 12640)) - (global $assembly/instructions/store/store_u32 i32 (i32.const 12672)) - (global $assembly/instructions/store/store_u64 i32 (i32.const 12704)) - (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 12736)) - (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 12768)) - (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 12800)) - (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 12832)) - (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 12864)) - (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 12896)) - (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 12928)) - (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 12960)) - (global $assembly/instructions/misc/INVALID i32 (i32.const 12992)) - (global $assembly/instructions/misc/trap i32 (i32.const 13024)) - (global $assembly/instructions/misc/fallthrough i32 (i32.const 13056)) - (global $assembly/instructions/misc/ecalli i32 (i32.const 13088)) - (global $assembly/instructions/misc/sbrk i32 (i32.const 13264)) - (global $assembly/instructions-exe/RUN i32 (i32.const 14240)) - (global $assembly/codec/MASKS i32 (i32.const 14320)) - (global $assembly/codec/variableLength i32 (i32.const 14368)) - (global $assembly/program/MAX_SKIP i32 (i32.const 24)) - (global $assembly/program/BasicBlock.NONE i32 (i32.const 0)) - (global $assembly/program/BasicBlock.START i32 (i32.const 2)) - (global $assembly/program/BasicBlock.END i32 (i32.const 4)) - (global $assembly/interpreter/Status.OK i32 (i32.const -1)) - (global $assembly/interpreter/Status.HALT i32 (i32.const 0)) - (global $assembly/interpreter/Status.PANIC i32 (i32.const 1)) - (global $assembly/interpreter/Status.FAULT i32 (i32.const 2)) - (global $assembly/interpreter/Status.HOST i32 (i32.const 3)) - (global $assembly/interpreter/Status.OOG i32 (i32.const 4)) - (global $assembly/interpreter/DjumpStatus.OK i32 (i32.const 0)) - (global $assembly/interpreter/DjumpStatus.HALT i32 (i32.const 1)) - (global $assembly/interpreter/DjumpStatus.PANIC i32 (i32.const 2)) - (global $assembly/interpreter/EXIT i32 (i32.const -65536)) - (global $assembly/interpreter/JUMP_ALIGMENT_FACTOR i32 (i32.const 2)) - (global $assembly/interpreter/MAX_U32 (mut i64) (i64.const 0)) - (global $assembly/api/interpreter (mut i32) (i32.const 0)) - (global $assembly/index/InputKind.Generic i32 (i32.const 0)) - (global $assembly/index/InputKind.SPI i32 (i32.const 1)) - (global $assembly/index/HasMetadata.Yes i32 (i32.const 0)) - (global $assembly/index/HasMetadata.No i32 (i32.const 1)) - (global $~lib/builtins/u32.MAX_VALUE i32 (i32.const -1)) - (global $~lib/rt/__rtti_base i32 (i32.const 20032)) - (global $~lib/memory/__data_end i32 (i32.const 20276)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 53044)) - (global $~lib/memory/__heap_base i32 (i32.const 53044)) - (memory $0 1) - (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") - (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $2 (i32.const 140) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") - (data $3 (i32.const 220) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00\a0\00\00\00\a0\00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $4 (i32.const 268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e\00\00\00\00\00") - (data $5 (i32.const 332) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $6 (i32.const 400) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $7 (i32.const 432) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $8 (i32.const 460) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e\00\00\00\00\00\00\00\00\00") - (data $9 (i32.const 524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $10 (i32.const 576) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $11 (i32.const 604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $12 (i32.const 668) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00") - (data $13 (i32.const 700) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $14 (i32.const 764) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") - (data $15 (i32.const 796) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") - (data $16 (i32.const 828) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\04\00\00\00\00\00\00\00\00\00\00\00") - (data $17 (i32.const 860) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\05\00\00\00\00\00\00\00\00\00\00\00") - (data $18 (i32.const 892) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\06\00\00\00\00\00\00\00\00\00\00\00") - (data $19 (i32.const 924) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\07\00\00\00\00\00\00\00\00\00\00\00") - (data $20 (i32.const 956) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00") - (data $21 (i32.const 988) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\t\00\00\00\00\00\00\00\00\00\00\00") - (data $22 (i32.const 1020) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") - (data $23 (i32.const 1052) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0b\00\00\00\00\00\00\00\00\00\00\00") - (data $24 (i32.const 1084) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0c\00\00\00\00\00\00\00\00\00\00\00") - (data $25 (i32.const 1116) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00") - (data $26 (i32.const 1148) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\b0\02\00\00\10\03\00\000\03\00\00P\03\00\00p\03\00\00\90\03\00\00\b0\03\00\00\d0\03\00\00\f0\03\00\00\10\04\00\000\04\00\00P\04\00\00p\04\00\00\00\00\00\00\00\00\00\00") - (data $27 (i32.const 1228) ",\00\00\00\00\00\00\00\00\00\00\00\07\00\00\00\10\00\00\00\90\04\00\00\90\04\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $28 (i32.const 1276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $29 (i32.const 1324) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00S\00B\00R\00K\00\00\00\00\00") - (data $30 (i32.const 1356) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00T\00R\00A\00P\00\00\00\00\00") - (data $31 (i32.const 1388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H\00\00\00\00\00\00\00") - (data $32 (i32.const 1436) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I\00") - (data $33 (i32.const 1468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00") - (data $34 (i32.const 1516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008\00\00\00\00\00") - (data $35 (i32.const 1564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006\00\00\00") - (data $36 (i32.const 1612) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002\00\00\00") - (data $37 (i32.const 1660) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004\00\00\00") - (data $38 (i32.const 1708) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00J\00U\00M\00P\00\00\00\00\00") - (data $39 (i32.const 1740) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $40 (i32.const 1788) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $41 (i32.const 1836) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $42 (i32.const 1884) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $43 (i32.const 1932) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $44 (i32.const 1980) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $45 (i32.const 2028) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $46 (i32.const 2076) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $47 (i32.const 2124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $48 (i32.const 2172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $49 (i32.const 2220) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") - (data $50 (i32.const 2268) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $51 (i32.const 2316) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $52 (i32.const 2364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $53 (i32.const 2428) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") - (data $54 (i32.const 2492) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $55 (i32.const 2556) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $56 (i32.const 2620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00\00\00") - (data $57 (i32.const 2668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M\00\00\00") - (data $58 (i32.const 2716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M\00\00\00") - (data $59 (i32.const 2764) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $60 (i32.const 2828) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $61 (i32.const 2892) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $62 (i32.const 2956) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $63 (i32.const 3020) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $64 (i32.const 3084) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $65 (i32.const 3148) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $66 (i32.const 3212) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $67 (i32.const 3276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $68 (i32.const 3324) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $69 (i32.const 3388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $70 (i32.const 3452) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00") - (data $71 (i32.const 3516) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00") - (data $72 (i32.const 3580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00") - (data $73 (i32.const 3644) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00") - (data $74 (i32.const 3708) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008\00\00\00") - (data $75 (i32.const 3756) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") - (data $76 (i32.const 3804) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") - (data $77 (i32.const 3852) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S\00\00\00") - (data $78 (i32.const 3900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00") - (data $79 (i32.const 3948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006\00\00\00") - (data $80 (i32.const 3996) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002\00\00\00") - (data $81 (i32.const 4044) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004\00\00\00") - (data $82 (i32.const 4092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00") - (data $83 (i32.const 4140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008\00\00\00\00\00\00\00") - (data $84 (i32.const 4188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00") - (data $85 (i32.const 4236) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006\00\00\00\00\00") - (data $86 (i32.const 4284) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00") - (data $87 (i32.const 4332) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002\00\00\00\00\00") - (data $88 (i32.const 4380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00") - (data $89 (i32.const 4428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") - (data $90 (i32.const 4476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $91 (i32.const 4524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $92 (i32.const 4572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M\00") - (data $93 (i32.const 4604) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") - (data $94 (i32.const 4652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") - (data $95 (i32.const 4700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") - (data $96 (i32.const 4748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $97 (i32.const 4796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $98 (i32.const 4844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $99 (i32.const 4892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00") - (data $100 (i32.const 4940) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") - (data $101 (i32.const 4988) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") - (data $102 (i32.const 5036) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $103 (i32.const 5100) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $104 (i32.const 5164) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $105 (i32.const 5228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") - (data $106 (i32.const 5276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") - (data $107 (i32.const 5324) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") - (data $108 (i32.const 5372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") - (data $109 (i32.const 5420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $110 (i32.const 5468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $111 (i32.const 5516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $112 (i32.const 5564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00") - (data $113 (i32.const 5612) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $114 (i32.const 5676) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $115 (i32.const 5740) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $116 (i32.const 5804) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00\00\00\00\00") - (data $117 (i32.const 5852) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $118 (i32.const 5916) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00\00\00\00\00") - (data $119 (i32.const 5964) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $120 (i32.const 6028) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00\00\00\00\00\00\00\00\00\00\00") - (data $121 (i32.const 6076) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00\00\00\00\00\00\00\00\00\00\00") - (data $122 (i32.const 6124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00\00\00\00\00\00\00") - (data $123 (i32.const 6172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00\00\00\00\00\00\00") - (data $124 (i32.const 6220) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00\00\00\00\00\00\00") - (data $125 (i32.const 6268) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00\00\00\00\00\00\00") - (data $126 (i32.const 6316) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00") - (data $127 (i32.const 6380) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002\00") - (data $128 (i32.const 6412) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002\00") - (data $129 (i32.const 6444) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002\00") - (data $130 (i32.const 6476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $131 (i32.const 6524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $132 (i32.const 6572) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $133 (i32.const 6620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $134 (i32.const 6668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $135 (i32.const 6716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $136 (i32.const 6764) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $137 (i32.const 6812) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004\00") - (data $138 (i32.const 6844) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004\00") - (data $139 (i32.const 6876) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004\00") - (data $140 (i32.const 6908) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $141 (i32.const 6956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $142 (i32.const 7004) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $143 (i32.const 7052) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $144 (i32.const 7100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $145 (i32.const 7148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $146 (i32.const 7196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $147 (i32.const 7244) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00A\00N\00D\00\00\00\00\00\00\00") - (data $148 (i32.const 7276) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00X\00O\00R\00\00\00\00\00\00\00") - (data $149 (i32.const 7308) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00O\00R\00\00\00\00\00\00\00\00\00") - (data $150 (i32.const 7340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S\00\00\00") - (data $151 (i32.const 7388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U\00\00\00") - (data $152 (i32.const 7436) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U\00\00\00") - (data $153 (i32.const 7484) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $154 (i32.const 7532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $155 (i32.const 7580) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $156 (i32.const 7628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $157 (i32.const 7676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $158 (i32.const 7724) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $159 (i32.const 7772) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $160 (i32.const 7820) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $161 (i32.const 7868) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $162 (i32.const 7916) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V\00") - (data $163 (i32.const 7948) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00X\00N\00O\00R\00\00\00\00\00") - (data $164 (i32.const 7980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00A\00X\00\00\00\00\00\00\00") - (data $165 (i32.const 8012) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00A\00X\00_\00U\00\00\00") - (data $166 (i32.const 8044) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00I\00N\00\00\00\00\00\00\00") - (data $167 (i32.const 8076) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00I\00N\00_\00U\00\00\00") - (data $168 (i32.const 8108) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00") - (data $169 (i32.const 8156) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h\00") - (data $170 (i32.const 8204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") - (data $171 (i32.const 8268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00") - (data $172 (i32.const 8332) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\0e\00\00\00\00\00\00\00\00\00\00\00") - (data $173 (i32.const 8364) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\0f\00\00\00\00\00\00\00\00\00\00\00") - (data $174 (i32.const 8396) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\10\00\00\00\00\00\00\00\00\00\00\00") - (data $175 (i32.const 8428) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\11\00\00\00\00\00\00\00\00\00\00\00") - (data $176 (i32.const 8460) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\12\00\00\00\00\00\00\00\00\00\00\00") - (data $177 (i32.const 8492) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\13\00\00\00\00\00\00\00\00\00\00\00") - (data $178 (i32.const 8524) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\14\00\00\00\00\00\00\00\00\00\00\00") - (data $179 (i32.const 8556) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\15\00\00\00\00\00\00\00\00\00\00\00") - (data $180 (i32.const 8588) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\16\00\00\00\00\00\00\00\00\00\00\00") - (data $181 (i32.const 8620) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\17\00\00\00\00\00\00\00\00\00\00\00") - (data $182 (i32.const 8652) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\18\00\00\00\00\00\00\00\00\00\00\00") - (data $183 (i32.const 8684) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\19\00\00\00\00\00\00\00\00\00\00\00") - (data $184 (i32.const 8716) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1a\00\00\00\00\00\00\00\00\00\00\00") - (data $185 (i32.const 8748) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1b\00\00\00\00\00\00\00\00\00\00\00") - (data $186 (i32.const 8780) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1c\00\00\00\00\00\00\00\00\00\00\00") - (data $187 (i32.const 8812) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1d\00\00\00\00\00\00\00\00\00\00\00") - (data $188 (i32.const 8844) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1e\00\00\00\00\00\00\00\00\00\00\00") - (data $189 (i32.const 8876) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1f\00\00\00\00\00\00\00\00\00\00\00") - (data $190 (i32.const 8908) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $191 (i32.const 8940) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00!\00\00\00\00\00\00\00\00\00\00\00") - (data $192 (i32.const 8972) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\"\00\00\00\00\00\00\00\00\00\00\00") - (data $193 (i32.const 9004) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00#\00\00\00\00\00\00\00\00\00\00\00") - (data $194 (i32.const 9036) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00$\00\00\00\00\00\00\00\00\00\00\00") - (data $195 (i32.const 9068) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00%\00\00\00\00\00\00\00\00\00\00\00") - (data $196 (i32.const 9100) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00&\00\00\00\00\00\00\00\00\00\00\00") - (data $197 (i32.const 9132) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\'\00\00\00\00\00\00\00\00\00\00\00") - (data $198 (i32.const 9164) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") - (data $199 (i32.const 9196) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") - (data $200 (i32.const 9228) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00*\00\00\00\00\00\00\00\00\00\00\00") - (data $201 (i32.const 9260) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00+\00\00\00\00\00\00\00\00\00\00\00") - (data $202 (i32.const 9292) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") - (data $203 (i32.const 9324) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00-\00\00\00\00\00\00\00\00\00\00\00") - (data $204 (i32.const 9356) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t\00\00\00\00\00\00\00\00\00") - (data $205 (i32.const 9420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s\00\00\00\00\00\00\00") - (data $206 (i32.const 9468) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $207 (i32.const 9596) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $208 (i32.const 9676) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00.\00\00\00\00\00\00\00\00\00\00\00") - (data $209 (i32.const 9708) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00/\00\00\00\00\00\00\00\00\00\00\00") - (data $210 (i32.const 9740) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\000\00\00\00\00\00\00\00\00\00\00\00") - (data $211 (i32.const 9772) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\001\00\00\00\00\00\00\00\00\00\00\00") - (data $212 (i32.const 9804) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\002\00\00\00\00\00\00\00\00\00\00\00") - (data $213 (i32.const 9836) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\003\00\00\00\00\00\00\00\00\00\00\00") - (data $214 (i32.const 9868) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\004\00\00\00\00\00\00\00\00\00\00\00") - (data $215 (i32.const 9900) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\005\00\00\00\00\00\00\00\00\00\00\00") - (data $216 (i32.const 9932) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\006\00\00\00\00\00\00\00\00\00\00\00") - (data $217 (i32.const 9964) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\007\00\00\00\00\00\00\00\00\00\00\00") - (data $218 (i32.const 9996) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\008\00\00\00\00\00\00\00\00\00\00\00") - (data $219 (i32.const 10028) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\009\00\00\00\00\00\00\00\00\00\00\00") - (data $220 (i32.const 10060) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00:\00\00\00\00\00\00\00\00\00\00\00") - (data $221 (i32.const 10092) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00;\00\00\00\00\00\00\00\00\00\00\00") - (data $222 (i32.const 10124) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00<\00\00\00\00\00\00\00\00\00\00\00") - (data $223 (i32.const 10156) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00=\00\00\00\00\00\00\00\00\00\00\00") - (data $224 (i32.const 10188) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00>\00\00\00\00\00\00\00\00\00\00\00") - (data $225 (i32.const 10220) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00?\00\00\00\00\00\00\00\00\00\00\00") - (data $226 (i32.const 10252) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00@\00\00\00\00\00\00\00\00\00\00\00") - (data $227 (i32.const 10284) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00A\00\00\00\00\00\00\00\00\00\00\00") - (data $228 (i32.const 10316) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00B\00\00\00\00\00\00\00\00\00\00\00") - (data $229 (i32.const 10348) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00C\00\00\00\00\00\00\00\00\00\00\00") - (data $230 (i32.const 10380) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00D\00\00\00\00\00\00\00\00\00\00\00") - (data $231 (i32.const 10412) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00E\00\00\00\00\00\00\00\00\00\00\00") - (data $232 (i32.const 10444) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00F\00\00\00\00\00\00\00\00\00\00\00") - (data $233 (i32.const 10476) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00G\00\00\00\00\00\00\00\00\00\00\00") - (data $234 (i32.const 10508) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00H\00\00\00\00\00\00\00\00\00\00\00") - (data $235 (i32.const 10540) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00I\00\00\00\00\00\00\00\00\00\00\00") - (data $236 (i32.const 10572) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00J\00\00\00\00\00\00\00\00\00\00\00") - (data $237 (i32.const 10604) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00K\00\00\00\00\00\00\00\00\00\00\00") - (data $238 (i32.const 10636) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00L\00\00\00\00\00\00\00\00\00\00\00") - (data $239 (i32.const 10668) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00M\00\00\00\00\00\00\00\00\00\00\00") - (data $240 (i32.const 10700) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00N\00\00\00\00\00\00\00\00\00\00\00") - (data $241 (i32.const 10732) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00O\00\00\00\00\00\00\00\00\00\00\00") - (data $242 (i32.const 10764) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00P\00\00\00\00\00\00\00\00\00\00\00") - (data $243 (i32.const 10796) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Q\00\00\00\00\00\00\00\00\00\00\00") - (data $244 (i32.const 10828) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00R\00\00\00\00\00\00\00\00\00\00\00") - (data $245 (i32.const 10860) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00S\00\00\00\00\00\00\00\00\00\00\00") - (data $246 (i32.const 10892) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00T\00\00\00\00\00\00\00\00\00\00\00") - (data $247 (i32.const 10924) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00U\00\00\00\00\00\00\00\00\00\00\00") - (data $248 (i32.const 10956) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00V\00\00\00\00\00\00\00\00\00\00\00") - (data $249 (i32.const 10988) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00W\00\00\00\00\00\00\00\00\00\00\00") - (data $250 (i32.const 11020) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00X\00\00\00\00\00\00\00\00\00\00\00") - (data $251 (i32.const 11052) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Y\00\00\00\00\00\00\00\00\00\00\00") - (data $252 (i32.const 11084) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Z\00\00\00\00\00\00\00\00\00\00\00") - (data $253 (i32.const 11116) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00[\00\00\00\00\00\00\00\00\00\00\00") - (data $254 (i32.const 11148) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\\\00\00\00\00\00\00\00\00\00\00\00") - (data $255 (i32.const 11180) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") - (data $256 (i32.const 11212) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00^\00\00\00\00\00\00\00\00\00\00\00") - (data $257 (i32.const 11244) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00_\00\00\00\00\00\00\00\00\00\00\00") - (data $258 (i32.const 11276) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00`\00\00\00\00\00\00\00\00\00\00\00") - (data $259 (i32.const 11308) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") - (data $260 (i32.const 11340) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") - (data $261 (i32.const 11372) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") - (data $262 (i32.const 11404) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") - (data $263 (i32.const 11436) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00e\00\00\00\00\00\00\00\00\00\00\00") - (data $264 (i32.const 11468) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00f\00\00\00\00\00\00\00\00\00\00\00") - (data $265 (i32.const 11500) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00g\00\00\00\00\00\00\00\00\00\00\00") - (data $266 (i32.const 11532) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00h\00\00\00\00\00\00\00\00\00\00\00") - (data $267 (i32.const 11564) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00i\00\00\00\00\00\00\00\00\00\00\00") - (data $268 (i32.const 11596) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00j\00\00\00\00\00\00\00\00\00\00\00") - (data $269 (i32.const 11628) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00k\00\00\00\00\00\00\00\00\00\00\00") - (data $270 (i32.const 11660) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00l\00\00\00\00\00\00\00\00\00\00\00") - (data $271 (i32.const 11692) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00m\00\00\00\00\00\00\00\00\00\00\00") - (data $272 (i32.const 11724) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00n\00\00\00\00\00\00\00\00\00\00\00") - (data $273 (i32.const 11756) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00o\00\00\00\00\00\00\00\00\00\00\00") - (data $274 (i32.const 11788) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00p\00\00\00\00\00\00\00\00\00\00\00") - (data $275 (i32.const 11820) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00q\00\00\00\00\00\00\00\00\00\00\00") - (data $276 (i32.const 11852) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00r\00\00\00\00\00\00\00\00\00\00\00") - (data $277 (i32.const 11884) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $278 (i32.const 11916) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00t\00\00\00\00\00\00\00\00\00\00\00") - (data $279 (i32.const 11948) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00u\00\00\00\00\00\00\00\00\00\00\00") - (data $280 (i32.const 11980) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00v\00\00\00\00\00\00\00\00\00\00\00") - (data $281 (i32.const 12012) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00w\00\00\00\00\00\00\00\00\00\00\00") - (data $282 (i32.const 12044) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00x\00\00\00\00\00\00\00\00\00\00\00") - (data $283 (i32.const 12076) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00y\00\00\00\00\00\00\00\00\00\00\00") - (data $284 (i32.const 12108) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00z\00\00\00\00\00\00\00\00\00\00\00") - (data $285 (i32.const 12140) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00{\00\00\00\00\00\00\00\00\00\00\00") - (data $286 (i32.const 12172) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00|\00\00\00\00\00\00\00\00\00\00\00") - (data $287 (i32.const 12204) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00}\00\00\00\00\00\00\00\00\00\00\00") - (data $288 (i32.const 12236) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00~\00\00\00\00\00\00\00\00\00\00\00") - (data $289 (i32.const 12268) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\7f\00\00\00\00\00\00\00\00\00\00\00") - (data $290 (i32.const 12300) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\80\00\00\00\00\00\00\00\00\00\00\00") - (data $291 (i32.const 12332) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\81\00\00\00\00\00\00\00\00\00\00\00") - (data $292 (i32.const 12364) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\82\00\00\00\00\00\00\00\00\00\00\00") - (data $293 (i32.const 12396) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\83\00\00\00\00\00\00\00\00\00\00\00") - (data $294 (i32.const 12428) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\84\00\00\00\00\00\00\00\00\00\00\00") - (data $295 (i32.const 12460) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\85\00\00\00\00\00\00\00\00\00\00\00") - (data $296 (i32.const 12492) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\86\00\00\00\00\00\00\00\00\00\00\00") - (data $297 (i32.const 12524) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\87\00\00\00\00\00\00\00\00\00\00\00") - (data $298 (i32.const 12556) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\88\00\00\00\00\00\00\00\00\00\00\00") - (data $299 (i32.const 12588) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\89\00\00\00\00\00\00\00\00\00\00\00") - (data $300 (i32.const 12620) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8a\00\00\00\00\00\00\00\00\00\00\00") - (data $301 (i32.const 12652) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8b\00\00\00\00\00\00\00\00\00\00\00") - (data $302 (i32.const 12684) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8c\00\00\00\00\00\00\00\00\00\00\00") - (data $303 (i32.const 12716) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8d\00\00\00\00\00\00\00\00\00\00\00") - (data $304 (i32.const 12748) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8e\00\00\00\00\00\00\00\00\00\00\00") - (data $305 (i32.const 12780) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8f\00\00\00\00\00\00\00\00\00\00\00") - (data $306 (i32.const 12812) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\90\00\00\00\00\00\00\00\00\00\00\00") - (data $307 (i32.const 12844) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\91\00\00\00\00\00\00\00\00\00\00\00") - (data $308 (i32.const 12876) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\92\00\00\00\00\00\00\00\00\00\00\00") - (data $309 (i32.const 12908) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\93\00\00\00\00\00\00\00\00\00\00\00") - (data $310 (i32.const 12940) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\94\00\00\00\00\00\00\00\00\00\00\00") - (data $311 (i32.const 12972) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\95\00\00\00\00\00\00\00\00\00\00\00") - (data $312 (i32.const 13004) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\96\00\00\00\00\00\00\00\00\00\00\00") - (data $313 (i32.const 13036) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\97\00\00\00\00\00\00\00\00\00\00\00") - (data $314 (i32.const 13068) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\98\00\00\00\00\00\00\00\00\00\00\00") - (data $315 (i32.const 13100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y\00") - (data $316 (i32.const 13148) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.\00") - (data $317 (i32.const 13244) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\99\00\00\00\00\00\00\00\00\00\00\00") - (data $318 (i32.const 13276) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00\e02\00\00\003\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 3\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00`$\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c00\00\00\e00\00\00\001\00\00 1\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\e0#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\00$\00\00\80$\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00@1\00\00`1\00\00\801\00\00\a01\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c01\00\00\e01\00\00\002\00\00 2\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 $\00\00\e0!\00\00\00\"\00\00 \"\00\00@\"\00\00`\"\00\00\80\"\00\00\a0\"\00\00\c0\"\00\00\e0\"\00\00\00#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 ,\00\00\d03\00\00\a0 \00\00\c0 \00\00\e0 \00\00\00!\00\00 !\00\00@!\00\00`!\00\00\80!\00\00\a0!\00\00\c0!\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00@2\00\00`2\00\00\802\00\00\a02\00\00\c0&\00\00\e0&\00\00\00\'\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\c0(\00\00\a0\'\00\00\c0\'\00\00\e0\'\00\00\e0(\00\00\c0-\00\00\e0-\00\00\80.\00\00\a0.\00\00\c0.\00\00\00)\00\00\00.\00\00 .\00\00\e0.\00\00\00/\00\00 /\00\00@,\00\00`,\00\00 )\00\00@)\00\00@/\00\00`/\00\00\80/\00\00`)\00\00\a0/\00\00\c0/\00\00\e0/\00\00\c0,\00\00\e0,\00\00\00-\00\00 -\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 #\00\00@#\00\00`#\00\00\80#\00\00\a0#\00\00\c0#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00@$\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\80)\00\00\a0)\00\00\c0)\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\00\000\00\00 0\00\00@0\00\00`*\00\00\80*\00\00\a0*\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00`0\00\00\800\00\00\a00\00\00\00(\00\00 (\00\00@(\00\00@+\00\00`+\00\00\80+\00\00@.\00\00`.\00\00\80,\00\00\a0,\00\00@-\00\00`-\00\00\80-\00\00\a0-\00\00`(\00\00\80(\00\00\a0(\00\00\a0+\00\00\c0+\00\00\e0+\00\00\00,\00\00") - (data $319 (i32.const 14220) ",\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\10\00\00\00\f03\00\00\f03\00\00\9c\03\00\00\e7\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $320 (i32.const 14268) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80\00\00\00\00") - (data $321 (i32.const 14300) ",\00\00\00\00\00\00\00\00\00\00\00\1b\00\00\00\10\00\00\00\d07\00\00\d07\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $322 (i32.const 14348) "\1c\00\00\00\00\00\00\00\00\00\00\00\1c\00\00\00\08\00\00\00\9a\00\00\00\00\00\00\00\00\00\00\00") - (data $323 (i32.const 14380) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $324 (i32.const 14412) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 \00\00\00") - (data $325 (i32.const 14492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $326 (i32.const 14540) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00`8\00\00\00\00\00\00\b08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $327 (i32.const 14588) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006\00\00\00\00\00\00\00\00\00") - (data $328 (i32.const 14716) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") - (data $329 (i32.const 14780) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\000\00\00\00\00\00\00\00\00\00\00\00") - (data $330 (i32.const 14812) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\00") - (data $331 (i32.const 15212) "\1c\04\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $332 (i32.const 16268) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z\00\00\00\00\00") - (data $333 (i32.const 16364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $334 (i32.const 16428) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 \00\00\00\00\00\00\00\00\00") - (data $335 (i32.const 16540) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $336 (i32.const 16588) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00@@\00\00\00\00\00\00\b0@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $337 (i32.const 16636) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n\00\00\00\00\00\00\00") - (data $338 (i32.const 16684) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\000\00x\00\00\00\00\00\00\00\00\00") - (data $339 (i32.const 16716) "\1c\00\00\00\00\00\00\00\00\00\00\00)\00\00\00\08\00\00\00\9b\00\00\00\00\00\00\00\00\00\00\00") - (data $340 (i32.const 16748) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00\n\00\n\00\00\00\00\00\00\00\00\00") - (data $341 (i32.const 16780) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $342 (i32.const 16908) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>\00\00\00") - (data $343 (i32.const 16988) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!\00\00\00\00\00\00\00\00\00\00\00") - (data $344 (i32.const 17100) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00g\00e\00n\00e\00r\00i\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $345 (i32.const 17180) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") - (data $346 (i32.const 17212) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00:\00 \00\00\00\00\00\00\00\00\00") - (data $347 (i32.const 17244) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") - (data $348 (i32.const 17276) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") - (data $349 (i32.const 17308) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pC\00\00\00\00\00\00\90C\00\00") - (data $350 (i32.const 17340) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $351 (i32.const 17372) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00,\00 \00\00\00\00\00\00\00\00\00") - (data $352 (i32.const 17404) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00\d0C\00\00\00\00\00\00\f0C\00\00") - (data $353 (i32.const 17436) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") - (data $354 (i32.const 17564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 \00") - (data $355 (i32.const 17612) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $356 (i32.const 17644) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $357 (i32.const 17676) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $358 (i32.const 17708) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $359 (i32.const 17740) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 \00") - (data $360 (i32.const 17836) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $361 (i32.const 17900) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!\00\00\00\00\00\00\00") - (data $362 (i32.const 18012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 \00\00\00\00\00") - (data $363 (i32.const 18060) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $364 (i32.const 18108) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pF\00\00\00\00\00\00\a0F\00\00") - (data $365 (i32.const 18140) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pF\00\00\00\00\00\00\a0F\00\00") - (data $366 (i32.const 18172) "\1c\00\00\00\00\00\00\00\00\00\00\005\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") - (data $367 (i32.const 18204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 \00") - (data $368 (i32.const 18268) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00P\00C\00 \00=\00 \00\00\00") - (data $369 (i32.const 18300) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $370 (i32.const 18348) "\1c\00\00\00\00\00\00\00\00\00\00\005\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") - (data $371 (i32.const 18380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 \00") - (data $372 (i32.const 18428) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00(\00\00\00\00\00\00\00\00\00") - (data $373 (i32.const 18460) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\14\00\00\00\e0G\00\00\00\00\00\00\10H\00\00\00\00\00\00\90C\00\00\00\00\00\00\00\00\00\00") - (data $374 (i32.const 18508) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 \00\00\00\00\00\00\00\00\00") - (data $375 (i32.const 18588) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00") - (data $376 (i32.const 18652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 \00\00\00") - (data $377 (i32.const 18700) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x\00") - (data $378 (i32.const 18732) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 \00\00\00") - (data $379 (i32.const 18764) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00,\00\n\00 \00 \00\00\00\00\00") - (data $380 (i32.const 18796) "|\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00`\00\00\00\f0H\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00@I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00`I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00`I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $381 (i32.const 18924) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t\00") - (data $382 (i32.const 18972) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $383 (i32.const 19052) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $384 (i32.const 19084) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $385 (i32.const 19116) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $386 (i32.const 19148) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $387 (i32.const 19180) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00S\00P\00I\00 \00r\00u\00n\00n\00i\00n\00g\00 \00n\00o\00t\00 \00s\00u\00p\00p\00o\00r\00t\00e\00d\00 \00y\00e\00t\00\00\00") - (data $388 (i32.const 19260) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00d\00e\00x\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $389 (i32.const 19324) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $390 (i32.const 19404) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $391 (i32.const 19436) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $392 (i32.const 19500) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 \00\00\00\00\00\00\00") - (data $393 (i32.const 19580) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00") - (data $394 (i32.const 19676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 \00\00\00\00\00") - (data $395 (i32.const 19724) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00\90L\00\00\00\00\00\00\f0L\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $396 (i32.const 19772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $397 (i32.const 19836) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $398 (i32.const 19868) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $399 (i32.const 19900) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d\00\00\00") - (data $400 (i32.const 19964) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d\00\00\00\00\00") - (data $401 (i32.const 20032) "<\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\02A\00\00B\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\01\00\00\00\00\00\00\00\00\00\00$\t\00\00 \00\00\00\00\00\00\00\00\00\00\00\04A\00\00 \00\00\00\00\00\00\00\02\01\00\00\02\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00\00\00\00\00 \00\00\00 \00\00\00\02A\00\00d\00\00\00\00\00\00\00") - (table $0 158 158 funcref) - (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $assembly/index/disassemble~anonymous|0 $assembly/api-generic/runVm~anonymous|0 $assembly/api-generic/runVm~anonymous|1) - (export "InputKind.Generic" (global $assembly/index/InputKind.Generic)) - (export "InputKind.SPI" (global $assembly/index/InputKind.SPI)) - (export "HasMetadata.Yes" (global $assembly/index/HasMetadata.Yes)) - (export "HasMetadata.No" (global $assembly/index/HasMetadata.No)) - (export "nextStep" (func $assembly/api/nextStep)) - (export "nSteps" (func $assembly/api/nSteps)) - (export "getProgramCounter" (func $assembly/api/getProgramCounter)) - (export "setNextProgramCounter" (func $assembly/api/setNextProgramCounter)) - (export "getStatus" (func $assembly/api/getStatus)) - (export "getExitArg" (func $assembly/api/getExitArg)) - (export "getGasLeft" (func $assembly/api/getGasLeft)) - (export "setGasLeft" (func $assembly/api/setGasLeft)) - (export "getRegisters" (func $assembly/api/getRegisters)) - (export "getPageDump" (func $assembly/api/getPageDump)) - (export "__new" (func $~lib/rt/itcms/__new)) - (export "__pin" (func $~lib/rt/itcms/__pin)) - (export "__unpin" (func $~lib/rt/itcms/__unpin)) - (export "__collect" (func $~lib/rt/itcms/__collect)) - (export "__rtti_base" (global $~lib/rt/__rtti_base)) - (export "memory" (memory $0)) - (export "__setArgumentsLength" (func $~setArgumentsLength)) - (export "disassemble" (func $export:assembly/index/disassemble)) - (export "runProgram" (func $export:assembly/index/runProgram)) - (export "runVm" (func $export:assembly/api-generic/runVm@varargs)) - (export "getAssembly" (func $export:assembly/api-generic/getAssembly)) - (export "wrapAsProgram" (func $export:assembly/program-build/wrapAsProgram)) - (export "resetGeneric" (func $export:assembly/api/resetGeneric)) - (export "resetGenericWithMemory" (func $export:assembly/api/resetGenericWithMemory)) - (export "setRegisters" (func $export:assembly/api/setRegisters)) - (export "setMemory" (func $export:assembly/api/setMemory)) - (start $~start) - (func $~lib/rt/itcms/Object#set:nextWithColor (param $this i32) (param $nextWithColor i32) - local.get $this - local.get $nextWithColor - i32.store offset=4 - ) - (func $~lib/rt/itcms/Object#set:prev (param $this i32) (param $prev i32) - local.get $this - local.get $prev - i32.store offset=8 - ) - (func $~lib/rt/itcms/initLazy (param $space i32) (result i32) - local.get $space - local.get $space - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $space - local.get $space - call $~lib/rt/itcms/Object#set:prev - local.get $space - return - ) - (func $~lib/rt/itcms/Object#get:nextWithColor (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/rt/itcms/Object#get:next (param $this i32) (result i32) - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.const -1 - i32.xor - i32.and - return - ) - (func $~lib/rt/itcms/Object#get:color (param $this i32) (result i32) - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.and - return - ) - (func $~lib/rt/itcms/visitRoots (param $cookie i32) - (local $pn i32) - (local $iter i32) - local.get $cookie - call $~lib/rt/__visit_globals - global.get $~lib/rt/itcms/pinSpace - local.set $pn - local.get $pn - call $~lib/rt/itcms/Object#get:next - local.set $iter - loop $while-continue|0 - local.get $iter - local.get $pn - i32.ne - if - i32.const 1 - drop - local.get $iter - call $~lib/rt/itcms/Object#get:color - i32.const 3 - i32.eq - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 160 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $iter - i32.const 20 - i32.add - local.get $cookie - call $~lib/rt/__visit_members - local.get $iter - call $~lib/rt/itcms/Object#get:next - local.set $iter - br $while-continue|0 - end - end - ) - (func $~lib/rt/itcms/Object#set:color (param $this i32) (param $color i32) - local.get $this - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $color - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - ) - (func $~lib/rt/itcms/Object#get:prev (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/rt/itcms/Object#set:next (param $this i32) (param $obj i32) - local.get $this - local.get $obj - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.and - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - ) - (func $~lib/rt/itcms/Object#unlink (param $this i32) - (local $next i32) - (local $prev i32) - local.get $this - call $~lib/rt/itcms/Object#get:next - local.set $next - local.get $next - i32.const 0 - i32.eq - if - i32.const 1 - drop - local.get $this - call $~lib/rt/itcms/Object#get:prev - i32.const 0 - i32.eq - if (result i32) - local.get $this - global.get $~lib/memory/__heap_base - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 128 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - return - end - local.get $this - call $~lib/rt/itcms/Object#get:prev - local.set $prev - i32.const 1 - drop - local.get $prev - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 132 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $next - local.get $prev - call $~lib/rt/itcms/Object#set:prev - local.get $prev - local.get $next - call $~lib/rt/itcms/Object#set:next - ) - (func $~lib/rt/itcms/Object#get:rtId (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/shared/typeinfo/Typeinfo#get:flags (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/__typeinfo (param $id i32) (result i32) - (local $ptr i32) - global.get $~lib/rt/__rtti_base - local.set $ptr - local.get $id - local.get $ptr - i32.load - i32.gt_u - if - i32.const 480 - i32.const 544 - i32.const 21 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $ptr - i32.const 4 - i32.add - local.get $id - i32.const 4 - i32.mul - i32.add - call $~lib/shared/typeinfo/Typeinfo#get:flags - return - ) - (func $~lib/rt/itcms/Object#get:isPointerfree (param $this i32) (result i32) - (local $rtId i32) - local.get $this - call $~lib/rt/itcms/Object#get:rtId - local.set $rtId - local.get $rtId - i32.const 2 - i32.le_u - if (result i32) - i32.const 1 - else - local.get $rtId - call $~lib/rt/__typeinfo - i32.const 32 - i32.and - i32.const 0 - i32.ne - end - return - ) - (func $~lib/rt/itcms/Object#linkTo (param $this i32) (param $list i32) (param $withColor i32) - (local $prev i32) - local.get $list - call $~lib/rt/itcms/Object#get:prev - local.set $prev - local.get $this - local.get $list - local.get $withColor - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $this - local.get $prev - call $~lib/rt/itcms/Object#set:prev - local.get $prev - local.get $this - call $~lib/rt/itcms/Object#set:next - local.get $list - local.get $this - call $~lib/rt/itcms/Object#set:prev - ) - (func $~lib/rt/itcms/Object#makeGray (param $this i32) - (local $1 i32) - local.get $this - global.get $~lib/rt/itcms/iter - i32.eq - if - local.get $this - call $~lib/rt/itcms/Object#get:prev - local.tee $1 - i32.eqz - if (result i32) - i32.const 0 - i32.const 352 - i32.const 148 - i32.const 30 - call $~lib/builtins/abort - unreachable - else - local.get $1 - end - global.set $~lib/rt/itcms/iter - end - local.get $this - call $~lib/rt/itcms/Object#unlink - local.get $this - global.get $~lib/rt/itcms/toSpace - local.get $this - call $~lib/rt/itcms/Object#get:isPointerfree - if (result i32) - global.get $~lib/rt/itcms/white - i32.eqz - else - i32.const 2 - end - call $~lib/rt/itcms/Object#linkTo - ) - (func $~lib/rt/itcms/__visit (param $ptr i32) (param $cookie i32) - (local $obj i32) - local.get $ptr - i32.eqz - if - return - end - local.get $ptr - i32.const 20 - i32.sub - local.set $obj - i32.const 0 - drop - local.get $obj - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eq - if - local.get $obj - call $~lib/rt/itcms/Object#makeGray - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.add - global.set $~lib/rt/itcms/visitCount - end - ) - (func $~lib/rt/itcms/visitStack (param $cookie i32) - (local $ptr i32) - global.get $~lib/memory/__stack_pointer - local.set $ptr - loop $while-continue|0 - local.get $ptr - global.get $~lib/memory/__heap_base - i32.lt_u - if - local.get $ptr - i32.load - local.get $cookie - call $~lib/rt/itcms/__visit - local.get $ptr - i32.const 4 - i32.add - local.set $ptr - br $while-continue|0 - end - end - ) - (func $~lib/rt/common/BLOCK#get:mmInfo (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/itcms/Object#get:size (param $this i32) (result i32) - i32.const 4 - local.get $this - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - return - ) - (func $~lib/rt/tlsf/Root#set:flMap (param $this i32) (param $flMap i32) - local.get $this - local.get $flMap - i32.store - ) - (func $~lib/rt/common/BLOCK#set:mmInfo (param $this i32) (param $mmInfo i32) - local.get $this - local.get $mmInfo - i32.store - ) - (func $~lib/rt/tlsf/Block#set:prev (param $this i32) (param $prev i32) - local.get $this - local.get $prev - i32.store offset=4 - ) - (func $~lib/rt/tlsf/Block#set:next (param $this i32) (param $next i32) - local.get $this - local.get $next - i32.store offset=8 - ) - (func $~lib/rt/tlsf/Block#get:prev (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/rt/tlsf/Block#get:next (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/rt/tlsf/Root#get:flMap (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/tlsf/removeBlock (param $root i32) (param $block i32) - (local $blockInfo i32) - (local $size i32) - (local $fl i32) - (local $sl i32) - (local $6 i32) - (local $7 i32) - (local $boundedSize i32) - (local $prev i32) - (local $next i32) - (local $root|11 i32) - (local $fl|12 i32) - (local $sl|13 i32) - (local $root|14 i32) - (local $fl|15 i32) - (local $sl|16 i32) - (local $head i32) - (local $root|18 i32) - (local $fl|19 i32) - (local $slMap i32) - (local $root|21 i32) - (local $fl|22 i32) - (local $slMap|23 i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $blockInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 268 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.set $size - i32.const 1 - drop - local.get $size - i32.const 12 - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 270 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - local.tee $6 - i32.const 1073741820 - local.tee $7 - local.get $6 - local.get $7 - i32.lt_u - select - local.set $boundedSize - i32.const 31 - local.get $boundedSize - i32.clz - i32.sub - local.set $fl - local.get $boundedSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 284 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $block - call $~lib/rt/tlsf/Block#get:prev - local.set $prev - local.get $block - call $~lib/rt/tlsf/Block#get:next - local.set $next - local.get $prev - if - local.get $prev - local.get $next - call $~lib/rt/tlsf/Block#set:next - end - local.get $next - if - local.get $next - local.get $prev - call $~lib/rt/tlsf/Block#set:prev - end - local.get $block - block $~lib/rt/tlsf/GETHEAD|inlined.0 (result i32) - local.get $root - local.set $root|11 - local.get $fl - local.set $fl|12 - local.get $sl - local.set $sl|13 - local.get $root|11 - local.get $fl|12 - i32.const 4 - i32.shl - local.get $sl|13 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.0 - end - i32.eq - if - local.get $root - local.set $root|14 - local.get $fl - local.set $fl|15 - local.get $sl - local.set $sl|16 - local.get $next - local.set $head - local.get $root|14 - local.get $fl|15 - i32.const 4 - i32.shl - local.get $sl|16 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head - i32.store offset=96 - local.get $next - i32.eqz - if - block $~lib/rt/tlsf/GETSL|inlined.0 (result i32) - local.get $root - local.set $root|18 - local.get $fl - local.set $fl|19 - local.get $root|18 - local.get $fl|19 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.0 - end - local.set $slMap - local.get $root - local.set $root|21 - local.get $fl - local.set $fl|22 - local.get $slMap - i32.const 1 - local.get $sl - i32.shl - i32.const -1 - i32.xor - i32.and - local.tee $slMap - local.set $slMap|23 - local.get $root|21 - local.get $fl|22 - i32.const 2 - i32.shl - i32.add - local.get $slMap|23 - i32.store offset=4 - local.get $slMap - i32.eqz - if - local.get $root - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 1 - local.get $fl - i32.shl - i32.const -1 - i32.xor - i32.and - call $~lib/rt/tlsf/Root#set:flMap - end - end - end - ) - (func $~lib/rt/tlsf/insertBlock (param $root i32) (param $block i32) - (local $blockInfo i32) - (local $block|3 i32) - (local $right i32) - (local $rightInfo i32) - (local $block|6 i32) - (local $block|7 i32) - (local $left i32) - (local $leftInfo i32) - (local $size i32) - (local $fl i32) - (local $sl i32) - (local $13 i32) - (local $14 i32) - (local $boundedSize i32) - (local $root|16 i32) - (local $fl|17 i32) - (local $sl|18 i32) - (local $head i32) - (local $root|20 i32) - (local $fl|21 i32) - (local $sl|22 i32) - (local $head|23 i32) - (local $root|24 i32) - (local $fl|25 i32) - (local $root|26 i32) - (local $fl|27 i32) - (local $slMap i32) - i32.const 1 - drop - local.get $block - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 201 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $blockInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 203 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETRIGHT|inlined.0 (result i32) - local.get $block - local.set $block|3 - local.get $block|3 - i32.const 4 - i32.add - local.get $block|3 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.0 - end - local.set $right - local.get $right - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $rightInfo - local.get $rightInfo - i32.const 1 - i32.and - if - local.get $root - local.get $right - call $~lib/rt/tlsf/removeBlock - local.get $block - local.get $blockInfo - i32.const 4 - i32.add - local.get $rightInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - local.tee $blockInfo - call $~lib/rt/common/BLOCK#set:mmInfo - block $~lib/rt/tlsf/GETRIGHT|inlined.1 (result i32) - local.get $block - local.set $block|6 - local.get $block|6 - i32.const 4 - i32.add - local.get $block|6 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.1 - end - local.set $right - local.get $right - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $rightInfo - end - local.get $blockInfo - i32.const 2 - i32.and - if - block $~lib/rt/tlsf/GETFREELEFT|inlined.0 (result i32) - local.get $block - local.set $block|7 - local.get $block|7 - i32.const 4 - i32.sub - i32.load - br $~lib/rt/tlsf/GETFREELEFT|inlined.0 - end - local.set $left - local.get $left - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $leftInfo - i32.const 1 - drop - local.get $leftInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 221 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $root - local.get $left - call $~lib/rt/tlsf/removeBlock - local.get $left - local.set $block - local.get $block - local.get $leftInfo - i32.const 4 - i32.add - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - local.tee $blockInfo - call $~lib/rt/common/BLOCK#set:mmInfo - end - local.get $right - local.get $rightInfo - i32.const 2 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.set $size - i32.const 1 - drop - local.get $size - i32.const 12 - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 233 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - i32.const 1 - drop - local.get $block - i32.const 4 - i32.add - local.get $size - i32.add - local.get $right - i32.eq - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 234 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $right - i32.const 4 - i32.sub - local.get $block - i32.store - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - local.tee $13 - i32.const 1073741820 - local.tee $14 - local.get $13 - local.get $14 - i32.lt_u - select - local.set $boundedSize - i32.const 31 - local.get $boundedSize - i32.clz - i32.sub - local.set $fl - local.get $boundedSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 251 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETHEAD|inlined.1 (result i32) - local.get $root - local.set $root|16 - local.get $fl - local.set $fl|17 - local.get $sl - local.set $sl|18 - local.get $root|16 - local.get $fl|17 - i32.const 4 - i32.shl - local.get $sl|18 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.1 - end - local.set $head - local.get $block - i32.const 0 - call $~lib/rt/tlsf/Block#set:prev - local.get $block - local.get $head - call $~lib/rt/tlsf/Block#set:next - local.get $head - if - local.get $head - local.get $block - call $~lib/rt/tlsf/Block#set:prev - end - local.get $root - local.set $root|20 - local.get $fl - local.set $fl|21 - local.get $sl - local.set $sl|22 - local.get $block - local.set $head|23 - local.get $root|20 - local.get $fl|21 - i32.const 4 - i32.shl - local.get $sl|22 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head|23 - i32.store offset=96 - local.get $root - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 1 - local.get $fl - i32.shl - i32.or - call $~lib/rt/tlsf/Root#set:flMap - local.get $root - local.set $root|26 - local.get $fl - local.set $fl|27 - block $~lib/rt/tlsf/GETSL|inlined.1 (result i32) - local.get $root - local.set $root|24 - local.get $fl - local.set $fl|25 - local.get $root|24 - local.get $fl|25 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.1 - end - i32.const 1 - local.get $sl - i32.shl - i32.or - local.set $slMap - local.get $root|26 - local.get $fl|27 - i32.const 2 - i32.shl - i32.add - local.get $slMap - i32.store offset=4 - ) - (func $~lib/rt/tlsf/addMemory (param $root i32) (param $start i32) (param $endU64 i64) (result i32) - (local $end i32) - (local $root|4 i32) - (local $tail i32) - (local $tailInfo i32) - (local $size i32) - (local $leftSize i32) - (local $left i32) - (local $root|10 i32) - (local $tail|11 i32) - local.get $endU64 - i32.wrap_i64 - local.set $end - i32.const 1 - drop - local.get $start - i64.extend_i32_u - local.get $endU64 - i64.le_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 382 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $start - i32.const 4 - i32.add - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - i32.const 4 - i32.sub - local.set $start - local.get $end - i32.const 15 - i32.const -1 - i32.xor - i32.and - local.set $end - block $~lib/rt/tlsf/GETTAIL|inlined.0 (result i32) - local.get $root - local.set $root|4 - local.get $root|4 - i32.load offset=1568 - br $~lib/rt/tlsf/GETTAIL|inlined.0 - end - local.set $tail - i32.const 0 - local.set $tailInfo - local.get $tail - if - i32.const 1 - drop - local.get $start - local.get $tail - i32.const 4 - i32.add - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 389 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $start - i32.const 16 - i32.sub - local.get $tail - i32.eq - if - local.get $start - i32.const 16 - i32.sub - local.set $start - local.get $tail - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $tailInfo - else - end - else - i32.const 1 - drop - local.get $start - local.get $root - i32.const 1572 - i32.add - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 402 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - end - local.get $end - local.get $start - i32.sub - local.set $size - local.get $size - i32.const 4 - i32.const 12 - i32.add - i32.const 4 - i32.add - i32.lt_u - if - i32.const 0 - return - end - local.get $size - i32.const 2 - i32.const 4 - i32.mul - i32.sub - local.set $leftSize - local.get $start - local.set $left - local.get $left - local.get $leftSize - i32.const 1 - i32.or - local.get $tailInfo - i32.const 2 - i32.and - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $left - i32.const 0 - call $~lib/rt/tlsf/Block#set:prev - local.get $left - i32.const 0 - call $~lib/rt/tlsf/Block#set:next - local.get $start - i32.const 4 - i32.add - local.get $leftSize - i32.add - local.set $tail - local.get $tail - i32.const 0 - i32.const 2 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.set $root|10 - local.get $tail - local.set $tail|11 - local.get $root|10 - local.get $tail|11 - i32.store offset=1568 - local.get $root - local.get $left - call $~lib/rt/tlsf/insertBlock - i32.const 1 - return - ) - (func $~lib/rt/tlsf/initialize - (local $rootOffset i32) - (local $pagesBefore i32) - (local $pagesNeeded i32) - (local $root i32) - (local $root|4 i32) - (local $tail i32) - (local $fl i32) - (local $root|7 i32) - (local $fl|8 i32) - (local $slMap i32) - (local $sl i32) - (local $root|11 i32) - (local $fl|12 i32) - (local $sl|13 i32) - (local $head i32) - (local $memStart i32) - i32.const 0 - drop - global.get $~lib/memory/__heap_base - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - local.set $rootOffset - memory.size - local.set $pagesBefore - local.get $rootOffset - i32.const 1572 - i32.add - i32.const 65535 - i32.add - i32.const 65535 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.shr_u - local.set $pagesNeeded - local.get $pagesNeeded - local.get $pagesBefore - i32.gt_s - if (result i32) - local.get $pagesNeeded - local.get $pagesBefore - i32.sub - memory.grow - i32.const 0 - i32.lt_s - else - i32.const 0 - end - if - unreachable - end - local.get $rootOffset - local.set $root - local.get $root - i32.const 0 - call $~lib/rt/tlsf/Root#set:flMap - local.get $root - local.set $root|4 - i32.const 0 - local.set $tail - local.get $root|4 - local.get $tail - i32.store offset=1568 - i32.const 0 - local.set $fl - loop $for-loop|0 - local.get $fl - i32.const 23 - i32.lt_u - if - local.get $root - local.set $root|7 - local.get $fl - local.set $fl|8 - i32.const 0 - local.set $slMap - local.get $root|7 - local.get $fl|8 - i32.const 2 - i32.shl - i32.add - local.get $slMap - i32.store offset=4 - i32.const 0 - local.set $sl - loop $for-loop|1 - local.get $sl - i32.const 16 - i32.lt_u - if - local.get $root - local.set $root|11 - local.get $fl - local.set $fl|12 - local.get $sl - local.set $sl|13 - i32.const 0 - local.set $head - local.get $root|11 - local.get $fl|12 - i32.const 4 - i32.shl - local.get $sl|13 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head - i32.store offset=96 - local.get $sl - i32.const 1 - i32.add - local.set $sl - br $for-loop|1 - end - end - local.get $fl - i32.const 1 - i32.add - local.set $fl - br $for-loop|0 - end - end - local.get $rootOffset - i32.const 1572 - i32.add - local.set $memStart - i32.const 0 - drop - local.get $root - local.get $memStart - memory.size - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - drop - local.get $root - global.set $~lib/rt/tlsf/ROOT - ) - (func $~lib/rt/tlsf/checkUsedBlock (param $ptr i32) (result i32) - (local $block i32) - local.get $ptr - i32.const 4 - i32.sub - local.set $block - local.get $ptr - i32.const 0 - i32.ne - if (result i32) - local.get $ptr - i32.const 15 - i32.and - i32.eqz - else - i32.const 0 - end - if (result i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 1 - i32.and - i32.eqz - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 562 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - local.get $block - return - ) - (func $~lib/rt/tlsf/freeBlock (param $root i32) (param $block i32) - i32.const 0 - drop - local.get $block - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 1 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.get $block - call $~lib/rt/tlsf/insertBlock - ) - (func $~lib/rt/tlsf/__free (param $ptr i32) - local.get $ptr - global.get $~lib/memory/__heap_base - i32.lt_u - if - return - end - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $ptr - call $~lib/rt/tlsf/checkUsedBlock - call $~lib/rt/tlsf/freeBlock - ) - (func $~lib/rt/itcms/free (param $obj i32) - local.get $obj - global.get $~lib/memory/__heap_base - i32.lt_u - if - local.get $obj - i32.const 0 - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $obj - i32.const 0 - call $~lib/rt/itcms/Object#set:prev - else - global.get $~lib/rt/itcms/total - local.get $obj - call $~lib/rt/itcms/Object#get:size - i32.sub - global.set $~lib/rt/itcms/total - i32.const 0 - drop - local.get $obj - i32.const 4 - i32.add - call $~lib/rt/tlsf/__free - end - ) - (func $~lib/rt/itcms/step (result i32) - (local $obj i32) - (local $1 i32) - (local $black i32) - (local $from i32) - block $break|0 - block $case2|0 - block $case1|0 - block $case0|0 - global.get $~lib/rt/itcms/state - local.set $1 - local.get $1 - i32.const 0 - i32.eq - br_if $case0|0 - local.get $1 - i32.const 1 - i32.eq - br_if $case1|0 - local.get $1 - i32.const 2 - i32.eq - br_if $case2|0 - br $break|0 - end - i32.const 1 - global.set $~lib/rt/itcms/state - i32.const 0 - global.set $~lib/rt/itcms/visitCount - i32.const 0 - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/iter - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - global.get $~lib/rt/itcms/white - i32.eqz - local.set $black - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - loop $while-continue|1 - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - global.set $~lib/rt/itcms/iter - local.get $obj - call $~lib/rt/itcms/Object#get:color - local.get $black - i32.ne - if - local.get $obj - local.get $black - call $~lib/rt/itcms/Object#set:color - i32.const 0 - global.set $~lib/rt/itcms/visitCount - local.get $obj - i32.const 20 - i32.add - i32.const 0 - call $~lib/rt/__visit_members - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - local.get $obj - call $~lib/rt/itcms/Object#get:next - local.set $obj - br $while-continue|1 - end - end - i32.const 0 - global.set $~lib/rt/itcms/visitCount - i32.const 0 - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.eq - if - i32.const 0 - call $~lib/rt/itcms/visitStack - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - loop $while-continue|2 - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - call $~lib/rt/itcms/Object#get:color - local.get $black - i32.ne - if - local.get $obj - local.get $black - call $~lib/rt/itcms/Object#set:color - local.get $obj - i32.const 20 - i32.add - i32.const 0 - call $~lib/rt/__visit_members - end - local.get $obj - call $~lib/rt/itcms/Object#get:next - local.set $obj - br $while-continue|2 - end - end - global.get $~lib/rt/itcms/fromSpace - local.set $from - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/fromSpace - local.get $from - global.set $~lib/rt/itcms/toSpace - local.get $black - global.set $~lib/rt/itcms/white - local.get $from - call $~lib/rt/itcms/Object#get:next - global.set $~lib/rt/itcms/iter - i32.const 2 - global.set $~lib/rt/itcms/state - end - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - global.get $~lib/rt/itcms/iter - local.set $obj - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - call $~lib/rt/itcms/Object#get:next - global.set $~lib/rt/itcms/iter - i32.const 1 - drop - local.get $obj - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eqz - i32.eq - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 229 - i32.const 20 - call $~lib/builtins/abort - unreachable - end - local.get $obj - call $~lib/rt/itcms/free - i32.const 10 - return - end - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - call $~lib/rt/itcms/Object#set:nextWithColor - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - call $~lib/rt/itcms/Object#set:prev - i32.const 0 - global.set $~lib/rt/itcms/state - br $break|0 - end - i32.const 0 - return - ) - (func $~lib/rt/itcms/interrupt - (local $budget i32) - i32.const 0 - drop - i32.const 0 - drop - i32.const 1024 - i32.const 200 - i32.mul - i32.const 100 - i32.div_u - local.set $budget - loop $do-loop|0 - local.get $budget - call $~lib/rt/itcms/step - i32.sub - local.set $budget - global.get $~lib/rt/itcms/state - i32.const 0 - i32.eq - if - i32.const 0 - drop - global.get $~lib/rt/itcms/total - i64.extend_i32_u - i32.const 200 - i64.extend_i32_u - i64.mul - i64.const 100 - i64.div_u - i32.wrap_i64 - i32.const 1024 - i32.add - global.set $~lib/rt/itcms/threshold - i32.const 0 - drop - return - end - local.get $budget - i32.const 0 - i32.gt_s - br_if $do-loop|0 - end - i32.const 0 - drop - global.get $~lib/rt/itcms/total - i32.const 1024 - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.sub - i32.const 1024 - i32.lt_u - i32.mul - i32.add - global.set $~lib/rt/itcms/threshold - i32.const 0 - drop - ) - (func $~lib/rt/tlsf/computeSize (param $size i32) (result i32) - local.get $size - i32.const 12 - i32.le_u - if (result i32) - i32.const 12 - else - local.get $size - i32.const 4 - i32.add - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - i32.const 4 - i32.sub - end - return - ) - (func $~lib/rt/tlsf/prepareSize (param $size i32) (result i32) - local.get $size - i32.const 1073741820 - i32.gt_u - if - i32.const 288 - i32.const 624 - i32.const 461 - i32.const 29 - call $~lib/builtins/abort - unreachable - end - local.get $size - call $~lib/rt/tlsf/computeSize - return - ) - (func $~lib/rt/tlsf/roundSize (param $size i32) (result i32) - local.get $size - i32.const 536870910 - i32.lt_u - if (result i32) - local.get $size - i32.const 1 - i32.const 27 - local.get $size - i32.clz - i32.sub - i32.shl - i32.add - i32.const 1 - i32.sub - else - local.get $size - end - return - ) - (func $~lib/rt/tlsf/searchBlock (param $root i32) (param $size i32) (result i32) - (local $fl i32) - (local $sl i32) - (local $requestSize i32) - (local $root|5 i32) - (local $fl|6 i32) - (local $slMap i32) - (local $head i32) - (local $flMap i32) - (local $root|10 i32) - (local $fl|11 i32) - (local $root|12 i32) - (local $fl|13 i32) - (local $sl|14 i32) - (local $root|15 i32) - (local $fl|16 i32) - (local $sl|17 i32) - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - call $~lib/rt/tlsf/roundSize - local.set $requestSize - i32.const 4 - i32.const 8 - i32.mul - i32.const 1 - i32.sub - local.get $requestSize - i32.clz - i32.sub - local.set $fl - local.get $requestSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 334 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETSL|inlined.2 (result i32) - local.get $root - local.set $root|5 - local.get $fl - local.set $fl|6 - local.get $root|5 - local.get $fl|6 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.2 - end - i32.const 0 - i32.const -1 - i32.xor - local.get $sl - i32.shl - i32.and - local.set $slMap - i32.const 0 - local.set $head - local.get $slMap - i32.eqz - if - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 0 - i32.const -1 - i32.xor - local.get $fl - i32.const 1 - i32.add - i32.shl - i32.and - local.set $flMap - local.get $flMap - i32.eqz - if - i32.const 0 - local.set $head - else - local.get $flMap - i32.ctz - local.set $fl - block $~lib/rt/tlsf/GETSL|inlined.3 (result i32) - local.get $root - local.set $root|10 - local.get $fl - local.set $fl|11 - local.get $root|10 - local.get $fl|11 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.3 - end - local.set $slMap - i32.const 1 - drop - local.get $slMap - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 347 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETHEAD|inlined.2 (result i32) - local.get $root - local.set $root|12 - local.get $fl - local.set $fl|13 - local.get $slMap - i32.ctz - local.set $sl|14 - local.get $root|12 - local.get $fl|13 - i32.const 4 - i32.shl - local.get $sl|14 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.2 - end - local.set $head - end - else - block $~lib/rt/tlsf/GETHEAD|inlined.3 (result i32) - local.get $root - local.set $root|15 - local.get $fl - local.set $fl|16 - local.get $slMap - i32.ctz - local.set $sl|17 - local.get $root|15 - local.get $fl|16 - i32.const 4 - i32.shl - local.get $sl|17 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.3 - end - local.set $head - end - local.get $head - return - ) - (func $~lib/rt/tlsf/growMemory (param $root i32) (param $size i32) - (local $pagesBefore i32) - (local $root|3 i32) - (local $pagesNeeded i32) - (local $5 i32) - (local $6 i32) - (local $pagesWanted i32) - (local $pagesAfter i32) - i32.const 0 - drop - local.get $size - i32.const 256 - i32.ge_u - if - local.get $size - call $~lib/rt/tlsf/roundSize - local.set $size - end - memory.size - local.set $pagesBefore - local.get $size - i32.const 4 - local.get $pagesBefore - i32.const 16 - i32.shl - i32.const 4 - i32.sub - block $~lib/rt/tlsf/GETTAIL|inlined.1 (result i32) - local.get $root - local.set $root|3 - local.get $root|3 - i32.load offset=1568 - br $~lib/rt/tlsf/GETTAIL|inlined.1 - end - i32.ne - i32.shl - i32.add - local.set $size - local.get $size - i32.const 65535 - i32.add - i32.const 65535 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.shr_u - local.set $pagesNeeded - local.get $pagesBefore - local.tee $5 - local.get $pagesNeeded - local.tee $6 - local.get $5 - local.get $6 - i32.gt_s - select - local.set $pagesWanted - local.get $pagesWanted - memory.grow - i32.const 0 - i32.lt_s - if - local.get $pagesNeeded - memory.grow - i32.const 0 - i32.lt_s - if - unreachable - end - end - memory.size - local.set $pagesAfter - local.get $root - local.get $pagesBefore - i32.const 16 - i32.shl - local.get $pagesAfter - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - drop - ) - (func $~lib/rt/tlsf/prepareBlock (param $root i32) (param $block i32) (param $size i32) - (local $blockInfo i32) - (local $remaining i32) - (local $spare i32) - (local $block|6 i32) - (local $block|7 i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $size - i32.const 4 - i32.add - i32.const 15 - i32.and - i32.eqz - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 361 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $size - i32.sub - local.set $remaining - local.get $remaining - i32.const 4 - i32.const 12 - i32.add - i32.ge_u - if - local.get $block - local.get $size - local.get $blockInfo - i32.const 2 - i32.and - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $block - i32.const 4 - i32.add - local.get $size - i32.add - local.set $spare - local.get $spare - local.get $remaining - i32.const 4 - i32.sub - i32.const 1 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.get $spare - call $~lib/rt/tlsf/insertBlock - else - local.get $block - local.get $blockInfo - i32.const 1 - i32.const -1 - i32.xor - i32.and - call $~lib/rt/common/BLOCK#set:mmInfo - block $~lib/rt/tlsf/GETRIGHT|inlined.3 (result i32) - local.get $block - local.set $block|7 - local.get $block|7 - i32.const 4 - i32.add - local.get $block|7 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.3 - end - block $~lib/rt/tlsf/GETRIGHT|inlined.2 (result i32) - local.get $block - local.set $block|6 - local.get $block|6 - i32.const 4 - i32.add - local.get $block|6 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.2 - end - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 2 - i32.const -1 - i32.xor - i32.and - call $~lib/rt/common/BLOCK#set:mmInfo - end - ) - (func $~lib/rt/tlsf/allocateBlock (param $root i32) (param $size i32) (result i32) - (local $payloadSize i32) - (local $block i32) - local.get $size - call $~lib/rt/tlsf/prepareSize - local.set $payloadSize - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/searchBlock - local.set $block - local.get $block - i32.eqz - if - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/growMemory - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/searchBlock - local.set $block - i32.const 1 - drop - local.get $block - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 499 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - end - i32.const 1 - drop - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $payloadSize - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 501 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $root - local.get $block - call $~lib/rt/tlsf/removeBlock - local.get $root - local.get $block - local.get $payloadSize - call $~lib/rt/tlsf/prepareBlock - i32.const 0 - drop - local.get $block - return - ) - (func $~lib/rt/tlsf/__alloc (param $size i32) (result i32) - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $size - call $~lib/rt/tlsf/allocateBlock - i32.const 4 - i32.add - return - ) - (func $~lib/rt/itcms/Object#set:rtId (param $this i32) (param $rtId i32) - local.get $this - local.get $rtId - i32.store offset=12 - ) - (func $~lib/rt/itcms/Object#set:rtSize (param $this i32) (param $rtSize i32) - local.get $this - local.get $rtSize - i32.store offset=16 - ) - (func $~lib/rt/itcms/__new (param $size i32) (param $id i32) (result i32) - (local $obj i32) - (local $ptr i32) - local.get $size - i32.const 1073741804 - i32.ge_u - if - i32.const 288 - i32.const 352 - i32.const 261 - i32.const 31 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.ge_u - if - call $~lib/rt/itcms/interrupt - end - i32.const 16 - local.get $size - i32.add - call $~lib/rt/tlsf/__alloc - i32.const 4 - i32.sub - local.set $obj - local.get $obj - local.get $id - call $~lib/rt/itcms/Object#set:rtId - local.get $obj - local.get $size - call $~lib/rt/itcms/Object#set:rtSize - local.get $obj - global.get $~lib/rt/itcms/fromSpace - global.get $~lib/rt/itcms/white - call $~lib/rt/itcms/Object#linkTo - global.get $~lib/rt/itcms/total - local.get $obj - call $~lib/rt/itcms/Object#get:size - i32.add - global.set $~lib/rt/itcms/total - local.get $obj - i32.const 20 - i32.add - local.set $ptr - local.get $ptr - i32.const 0 - local.get $size - memory.fill - local.get $ptr - return - ) - (func $assembly/arguments/Args#set:a (param $this i32) (param $a i32) - local.get $this - local.get $a - i32.store - ) - (func $assembly/arguments/Args#set:b (param $this i32) (param $b i32) - local.get $this - local.get $b - i32.store offset=4 - ) - (func $assembly/arguments/Args#set:c (param $this i32) (param $c i32) - local.get $this - local.get $c - i32.store offset=8 - ) - (func $assembly/arguments/Args#set:d (param $this i32) (param $d i32) - local.get $this - local.get $d - i32.store offset=12 - ) - (func $start:assembly/arguments~anonymous|0 (param $_d i32) (param $_l i32) (result i32) - i32.const 0 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - return - ) - (func $~lib/arraybuffer/ArrayBufferView#get:byteLength (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/arraybuffer/ArrayBufferView#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/itcms/__link (param $parentPtr i32) (param $childPtr i32) (param $expectMultiple i32) - (local $child i32) - (local $parent i32) - (local $parentColor i32) - local.get $childPtr - i32.eqz - if - return - end - i32.const 1 - drop - local.get $parentPtr - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 295 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $childPtr - i32.const 20 - i32.sub - local.set $child - local.get $child - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eq - if - local.get $parentPtr - i32.const 20 - i32.sub - local.set $parent - local.get $parent - call $~lib/rt/itcms/Object#get:color - local.set $parentColor - local.get $parentColor - global.get $~lib/rt/itcms/white - i32.eqz - i32.eq - if - local.get $expectMultiple - if - local.get $parent - call $~lib/rt/itcms/Object#makeGray - else - local.get $child - call $~lib/rt/itcms/Object#makeGray - end - else - local.get $parentColor - i32.const 3 - i32.eq - if (result i32) - global.get $~lib/rt/itcms/state - i32.const 1 - i32.eq - else - i32.const 0 - end - if - local.get $child - call $~lib/rt/itcms/Object#makeGray - end - end - end - ) - (func $~lib/arraybuffer/ArrayBufferView#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/arguments/Nibbles#set:low (param $this i32) (param $low i32) - local.get $this - local.get $low - i32.store8 - ) - (func $assembly/arguments/Nibbles#set:hig (param $this i32) (param $hig i32) - local.get $this - local.get $hig - i32.store8 offset=1 - ) - (func $assembly/arguments/Nibbles#get:low (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $assembly/arguments/Nibbles#get:hig (param $this i32) (result i32) - local.get $this - i32.load8_u offset=1 - ) - (func $assembly/arguments/Args#get:a (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/arguments/Args#get:b (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $start:assembly/arguments - (local $0 i32) - (local $1 i32) - (local $2 i32) - memory.size - i32.const 16 - i32.shl - global.get $~lib/memory/__heap_base - i32.sub - i32.const 1 - i32.shr_u - global.set $~lib/rt/itcms/threshold - i32.const 400 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/pinSpace - i32.const 432 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/toSpace - i32.const 576 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/fromSpace - ) - (func $assembly/instructions/Instruction#set:namePtr (param $this i32) (param $namePtr i32) - local.get $this - local.get $namePtr - i32.store - ) - (func $assembly/instructions/Instruction#set:kind (param $this i32) (param $kind i32) - local.get $this - local.get $kind - i32.store offset=4 - ) - (func $assembly/instructions/Instruction#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/instructions/Instruction#set:isTerminating (param $this i32) (param $isTerminating i32) - local.get $this - local.get $isTerminating - i32.store8 offset=16 - ) - (func $assembly/instructions/Instruction#constructor (param $this i32) (result i32) - local.get $this - i32.eqz - if - i32.const 17 - call $~lib/rt/tlsf/__alloc - local.set $this - end - local.get $this - i32.const 0 - call $assembly/instructions/Instruction#set:namePtr - local.get $this - global.get $assembly/arguments/Arguments.Zero - call $assembly/instructions/Instruction#set:kind - local.get $this - i64.const 0 - call $assembly/instructions/Instruction#set:gas - local.get $this - i32.const 0 - call $assembly/instructions/Instruction#set:isTerminating - local.get $this - ) - (func $assembly/instructions/instruction (param $name i32) (param $kind i32) (param $gas i64) (param $isTerminating i32) (result i32) - (local $i i32) - i32.const 0 - call $assembly/instructions/Instruction#constructor - local.set $i - local.get $i - local.get $name - call $assembly/instructions/Instruction#set:namePtr - local.get $i - local.get $kind - call $assembly/instructions/Instruction#set:kind - local.get $i - local.get $gas - call $assembly/instructions/Instruction#set:gas - local.get $i - local.get $isTerminating - call $assembly/instructions/Instruction#set:isTerminating - local.get $i - return - ) - (func $~lib/rt/__newBuffer (param $size i32) (param $id i32) (param $data i32) (result i32) - (local $buffer i32) - local.get $size - local.get $id - call $~lib/rt/itcms/__new - local.set $buffer - local.get $data - if - local.get $buffer - local.get $data - local.get $size - memory.copy - end - local.get $buffer - return - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/rt/itcms/Object#get:rtSize (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $~lib/rt/itcms/__renew (param $oldPtr i32) (param $size i32) (result i32) - (local $oldObj i32) - (local $newPtr i32) - (local $4 i32) - (local $5 i32) - local.get $oldPtr - i32.const 20 - i32.sub - local.set $oldObj - local.get $size - local.get $oldObj - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.sub - i32.le_u - if - local.get $oldObj - local.get $size - call $~lib/rt/itcms/Object#set:rtSize - local.get $oldPtr - return - end - local.get $size - local.get $oldObj - call $~lib/rt/itcms/Object#get:rtId - call $~lib/rt/itcms/__new - local.set $newPtr - local.get $newPtr - local.get $oldPtr - local.get $size - local.tee $4 - local.get $oldObj - call $~lib/rt/itcms/Object#get:rtSize - local.tee $5 - local.get $4 - local.get $5 - i32.lt_u - select - memory.copy - local.get $newPtr - return - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/math/ipow32 (param $x i32) (param $e i32) (result i32) - (local $out i32) - (local $log i32) - (local $4 i32) - i32.const 1 - local.set $out - i32.const 0 - i32.const 1 - i32.lt_s - drop - local.get $x - i32.const 2 - i32.eq - if - i32.const 1 - local.get $e - i32.shl - i32.const 0 - local.get $e - i32.const 32 - i32.lt_u - select - return - end - local.get $e - i32.const 0 - i32.le_s - if - local.get $x - i32.const -1 - i32.eq - if - i32.const -1 - i32.const 1 - local.get $e - i32.const 1 - i32.and - select - return - end - local.get $e - i32.const 0 - i32.eq - local.get $x - i32.const 1 - i32.eq - i32.or - return - else - local.get $e - i32.const 1 - i32.eq - if - local.get $x - return - else - local.get $e - i32.const 2 - i32.eq - if - local.get $x - local.get $x - i32.mul - return - else - local.get $e - i32.const 32 - i32.lt_s - if - i32.const 32 - local.get $e - i32.clz - i32.sub - local.set $log - block $break|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $log - local.set $4 - local.get $4 - i32.const 5 - i32.eq - br_if $case0|0 - local.get $4 - i32.const 4 - i32.eq - br_if $case1|0 - local.get $4 - i32.const 3 - i32.eq - br_if $case2|0 - local.get $4 - i32.const 2 - i32.eq - br_if $case3|0 - local.get $4 - i32.const 1 - i32.eq - br_if $case4|0 - br $break|0 - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - end - local.get $out - return - end - end - end - end - loop $while-continue|1 - local.get $e - if - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - br $while-continue|1 - end - end - local.get $out - return - ) - (func $start:assembly/memory-page - i32.const 2 - i32.const 16 - call $~lib/math/ipow32 - global.set $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/PAGE_SIZE - i32.div_u - global.set $assembly/memory-page/RESERVED_PAGES - i32.const 2 - i32.const 29 - call $~lib/math/ipow32 - global.set $assembly/memory-page/ALLOCATE_EAGERLY - ) - (func $assembly/memory/MaybePageFault#set:isFault (param $this i32) (param $isFault i32) - local.get $this - local.get $isFault - i32.store8 - ) - (func $assembly/memory/MaybePageFault#set:isAccess (param $this i32) (param $isAccess i32) - local.get $this - local.get $isAccess - i32.store8 offset=1 - ) - (func $assembly/memory/MaybePageFault#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store offset=4 - ) - (func $~lib/arraybuffer/ArrayBufferView#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/arraybuffer/ArrayBufferView#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/arraybuffer/ArrayBufferView#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $assembly/memory-page/Page#set:access (param $this i32) (param $access i32) - local.get $this - local.get $access - i32.store - ) - (func $assembly/memory-page/Page#set:raw (param $this i32) (param $raw i32) - local.get $this - local.get $raw - i32.store offset=4 - local.get $this - local.get $raw - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/RawPage#set:id (param $this i32) (param $id i32) - local.get $this - local.get $id - i32.store - ) - (func $assembly/memory-page/RawPage#set:page (param $this i32) (param $page i32) - local.get $this - local.get $page - i32.store offset=4 - local.get $this - local.get $page - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $start:assembly/instructions/outcome - call $start:assembly/memory - ) - (func $assembly/instructions/utils/reg (param $v i64) (result i32) - local.get $v - global.get $assembly/registers/NO_OF_REGISTERS - i64.extend_i32_s - i64.ge_u - if (result i32) - global.get $assembly/registers/NO_OF_REGISTERS - i32.const 1 - i32.sub - else - local.get $v - i32.wrap_i64 - end - return - ) - (func $~lib/rt/common/OBJECT#get:rtSize (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 3 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i64) - local.get $this - local.get $index - i32.const 3 - i32.shl - i32.add - local.get $value - i64.store - i32.const 0 - drop - ) - (func $assembly/instructions/outcome/OutcomeData#set:outcome (param $this i32) (param $outcome i32) - local.get $this - local.get $outcome - i32.store - ) - (func $assembly/instructions/outcome/OutcomeData#set:staticJump (param $this i32) (param $staticJump i32) - local.get $this - local.get $staticJump - i32.store offset=4 - ) - (func $assembly/instructions/outcome/OutcomeData#set:dJump (param $this i32) (param $dJump i32) - local.get $this - local.get $dJump - i32.store offset=8 - ) - (func $assembly/instructions/outcome/OutcomeData#set:result (param $this i32) (param $result i32) - local.get $this - local.get $result - i32.store offset=12 - ) - (func $assembly/instructions/outcome/OutcomeData#set:exitCode (param $this i32) (param $exitCode i32) - local.get $this - local.get $exitCode - i32.store offset=16 - ) - (func $assembly/instructions/outcome/ok (result i32) - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - return - ) - (func $assembly/instructions/utils/u8SignExtend (param $v i32) (result i64) - local.get $v - i32.extend8_s - i64.extend_i32_s - return - ) - (func $assembly/instructions/utils/u16SignExtend (param $v i32) (result i64) - local.get $v - i32.extend16_s - i64.extend_i32_s - return - ) - (func $~lib/polyfills/bswap (param $value i64) (result i64) - (local $a i64) - (local $b i64) - (local $v i64) - i32.const 1 - drop - i32.const 8 - i32.const 1 - i32.eq - drop - i32.const 8 - i32.const 2 - i32.eq - drop - i32.const 8 - i32.const 4 - i32.eq - drop - i32.const 8 - i32.const 8 - i32.eq - drop - local.get $value - i64.const 8 - i64.shr_u - i64.const 71777214294589695 - i64.and - local.set $a - local.get $value - i64.const 71777214294589695 - i64.and - i64.const 8 - i64.shl - local.set $b - local.get $a - local.get $b - i64.or - local.set $v - local.get $v - i64.const 16 - i64.shr_u - i64.const 281470681808895 - i64.and - local.set $a - local.get $v - i64.const 281470681808895 - i64.and - i64.const 16 - i64.shl - local.set $b - local.get $a - local.get $b - i64.or - i64.const 32 - i64.rotr - return - ) - (func $start:assembly/instructions/bit - call $start:assembly/instructions/outcome - ) - (func $assembly/instructions/utils/u32SignExtend (param $v i32) (result i64) - local.get $v - i64.extend_i32_s - return - ) - (func $assembly/arguments/Args#get:c (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/arguments/Args#get:d (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/memory/Chunks#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#set:first (param $this i32) (param $first i32) - local.get $this - local.get $first - i32.store offset=4 - local.get $this - local.get $first - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#set:second (param $this i32) (param $second i32) - local.get $this - local.get $second - i32.store offset=8 - local.get $this - local.get $second - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#get:pages (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/util/hash/HASH (param $key i32) (result i32) - (local $key|1 i32) - (local $len i32) - (local $h i32) - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 4 - i32.const 4 - i32.le_u - drop - block $~lib/util/hash/hash32|inlined.0 (result i32) - local.get $key - local.set $key|1 - i32.const 4 - local.set $len - i32.const 0 - i32.const 374761393 - i32.add - local.get $len - i32.add - local.set $h - local.get $h - local.get $key|1 - i32.const -1028477379 - i32.mul - i32.add - local.set $h - local.get $h - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 15 - i32.shr_u - i32.xor - local.set $h - local.get $h - i32.const -2048144777 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 13 - i32.shr_u - i32.xor - local.set $h - local.get $h - i32.const -1028477379 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 16 - i32.shr_u - i32.xor - local.set $h - local.get $h - br $~lib/util/hash/hash32|inlined.0 - end - return - ) - (func $"~lib/map/Map#get:buckets" (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $"~lib/map/Map#get:bucketsMask" (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $"~lib/map/MapEntry#get:taggedNext" (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#get:key" (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/PageData#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/PageData#set:page (param $this i32) (param $page i32) - local.get $this - local.get $page - i32.store offset=4 - local.get $this - local.get $page - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/PageData#set:relativeAddress (param $this i32) (param $relativeAddress i32) - local.get $this - local.get $relativeAddress - i32.store offset=8 - ) - (func $"~lib/map/MapEntry#get:value" (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Page#get:access (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/PageData#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/MaybePageFault#get:isFault (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $assembly/memory/PageData#get:page (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/PageData#get:relativeAddress (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/memory-page/Page#get:raw (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/RawPage#get:page (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i32) (param $start i32) (param $end i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $start - i32.add - local.tee $5 - i32.const 0 - local.tee $6 - local.get $5 - local.get $6 - i32.gt_u - select - else - local.get $start - local.tee $7 - local.get $len - local.tee $8 - local.get $7 - local.get $8 - i32.lt_s - select - end - local.set $start - local.get $end - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $end - i32.add - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_u - select - else - local.get $end - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - end - local.set $end - i32.const 1 - i32.const 1 - i32.eq - drop - local.get $start - local.get $end - i32.lt_s - if - local.get $ptr - local.get $start - i32.add - local.get $value - local.get $end - local.get $start - i32.sub - memory.fill - end - ) - (func $assembly/memory/Chunks#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/ChunkBytes#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/ChunkBytes#set:bytes (param $this i32) (param $bytes i32) - local.get $this - local.get $bytes - i32.store offset=4 - local.get $this - local.get $bytes - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#get:first (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/Chunks#get:second (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 0 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - i32.const 0 - drop - ) - (func $assembly/memory/Result#set:ok (param $this i32) (param $ok i64) - local.get $this - local.get $ok - i64.store - ) - (func $assembly/memory/Result#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store offset=8 - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/ChunkBytes#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/ChunkBytes#get:bytes (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/Result#get:fault (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/memory/Result#get:ok (param $this i32) (result i64) - local.get $this - i64.load - ) - (func $assembly/memory/MaybePageFault#get:isAccess (param $this i32) (result i32) - local.get $this - i32.load8_u offset=1 - ) - (func $assembly/memory/MaybePageFault#get:fault (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/math/ipow64 (param $x i64) (param $e i64) (result i64) - (local $out i64) - (local $log i32) - (local $4 i32) - i64.const 1 - local.set $out - i32.const 0 - i32.const 1 - i32.lt_s - drop - local.get $x - i64.const 2 - i64.eq - if - i64.const 1 - local.get $e - i64.shl - i64.const 0 - local.get $e - i64.const 64 - i64.lt_u - select - return - end - local.get $e - i64.const 0 - i64.le_s - if - local.get $x - i64.const -1 - i64.eq - if - i64.const -1 - i64.const 1 - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - select - return - end - local.get $e - i64.const 0 - i64.eq - i64.extend_i32_u - local.get $x - i64.const 1 - i64.eq - i64.extend_i32_u - i64.or - return - else - local.get $e - i64.const 1 - i64.eq - if - local.get $x - return - else - local.get $e - i64.const 2 - i64.eq - if - local.get $x - local.get $x - i64.mul - return - else - local.get $e - i64.const 64 - i64.lt_s - if - i32.const 64 - local.get $e - i64.clz - i32.wrap_i64 - i32.sub - local.set $log - block $break|0 - block $case5|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $log - local.set $4 - local.get $4 - i32.const 6 - i32.eq - br_if $case0|0 - local.get $4 - i32.const 5 - i32.eq - br_if $case1|0 - local.get $4 - i32.const 4 - i32.eq - br_if $case2|0 - local.get $4 - i32.const 3 - i32.eq - br_if $case3|0 - local.get $4 - i32.const 2 - i32.eq - br_if $case4|0 - local.get $4 - i32.const 1 - i32.eq - br_if $case5|0 - br $break|0 - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - end - local.get $out - return - end - end - end - end - loop $while-continue|1 - local.get $e - i64.const 0 - i64.ne - if - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - br $while-continue|1 - end - end - local.get $out - return - ) - (func $assembly/instructions/utils/mulUpperUnsigned (param $a i64) (param $b i64) (result i64) - (local $aHigh i64) - (local $aLow i64) - (local $bHigh i64) - (local $bLow i64) - (local $lowLow i64) - (local $lowHigh i64) - (local $highLow i64) - (local $highHigh i64) - (local $carry i64) - local.get $a - i64.const 32 - i64.shr_u - local.set $aHigh - local.get $a - i64.const 4294967295 - i64.and - local.set $aLow - local.get $b - i64.const 32 - i64.shr_u - local.set $bHigh - local.get $b - i64.const 4294967295 - i64.and - local.set $bLow - local.get $aLow - local.get $bLow - i64.mul - local.set $lowLow - local.get $aLow - local.get $bHigh - i64.mul - local.set $lowHigh - local.get $aHigh - local.get $bLow - i64.mul - local.set $highLow - local.get $aHigh - local.get $bHigh - i64.mul - local.set $highHigh - local.get $lowLow - i64.const 32 - i64.shr_u - local.get $lowHigh - i64.const 4294967295 - i64.and - i64.add - local.get $highLow - i64.const 4294967295 - i64.and - i64.add - local.set $carry - local.get $highHigh - local.get $lowHigh - i64.const 32 - i64.shr_u - i64.add - local.get $highLow - i64.const 32 - i64.shr_u - i64.add - local.get $carry - i64.const 32 - i64.shr_u - i64.add - return - ) - (func $assembly/instructions/utils/mulUpperSigned (param $a i64) (param $b i64) (result i64) - (local $isResultNegative i32) - (local $aAbs i64) - (local $bAbs i64) - (local $upper i64) - (local $lower i64) - i32.const 0 - local.set $isResultNegative - local.get $a - local.set $aAbs - local.get $b - local.set $bAbs - local.get $a - i64.const 0 - i64.lt_s - if - local.get $isResultNegative - i32.eqz - local.set $isResultNegative - local.get $a - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $aAbs - end - local.get $b - i64.const 0 - i64.lt_s - if - local.get $isResultNegative - i32.eqz - local.set $isResultNegative - local.get $b - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $bAbs - end - local.get $isResultNegative - if - local.get $aAbs - local.get $bAbs - call $assembly/instructions/utils/mulUpperUnsigned - local.set $upper - local.get $aAbs - local.get $bAbs - i64.mul - local.set $lower - local.get $upper - i64.const -1 - i64.xor - local.get $lower - i64.const 0 - i64.eq - if (result i64) - i64.const 1 - else - i64.const 0 - end - i64.add - return - end - local.get $aAbs - local.get $bAbs - call $assembly/instructions/utils/mulUpperUnsigned - return - ) - (func $assembly/instructions/utils/mulUpperSignedUnsigned (param $a i64) (param $b i64) (result i64) - (local $aAbs i64) - (local $upper i64) - (local $lower i64) - local.get $a - i64.const 0 - i64.lt_s - if - local.get $a - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $aAbs - local.get $aAbs - local.get $b - call $assembly/instructions/utils/mulUpperUnsigned - local.set $upper - local.get $aAbs - local.get $b - i64.mul - local.set $lower - local.get $upper - i64.const -1 - i64.xor - local.get $lower - i64.const 0 - i64.eq - if (result i64) - i64.const 1 - else - i64.const 0 - end - i64.add - return - end - local.get $a - local.get $b - call $assembly/instructions/utils/mulUpperUnsigned - return - ) - (func $assembly/instructions/rot/math.rot_r (param $v i64) (param $shift i64) (result i64) - local.get $v - local.get $shift - i64.rotr - return - ) - (func $assembly/instructions/rot/math.rot_r_32 (param $v i32) (param $shift i32) (result i32) - local.get $v - local.get $shift - i32.rotr - return - ) - (func $assembly/instructions/rot/math.rot_l (param $v i64) (param $shift i64) (result i64) - local.get $v - local.get $shift - i64.rotl - return - ) - (func $assembly/instructions/rot/math.rot_l_32 (param $v i32) (param $shift i32) (result i32) - local.get $v - local.get $shift - i32.rotl - return - ) - (func $assembly/instructions/outcome/panic (result i32) - global.get $assembly/instructions/outcome/Result.PANIC - call $assembly/instructions/outcome/status - return - ) - (func $start:assembly/instructions/misc~anonymous|0 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/panic - ) - (func $start:assembly/instructions/misc~anonymous|1 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/panic - ) - (func $start:assembly/instructions/misc~anonymous|2 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/ok - ) - (func $assembly/memory/Memory#get:sbrkAddress (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/memory/Memory#set:sbrkAddress (param $this i32) (param $sbrkAddress i32) - local.get $this - local.get $sbrkAddress - i32.store offset=12 - ) - (func $assembly/memory/Memory#get:lastAllocatedPage (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/Memory#get:arena (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Arena#get:free (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $assembly/memory-page/Arena#get:extraPageIndex (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/memory-page/Arena#get:arenaBytes (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Arena#set:extraPageIndex (param $this i32) (param $extraPageIndex i32) - local.get $this - local.get $extraPageIndex - i32.store offset=8 - ) - (func $"~lib/map/MapEntry#set:value" (param $this i32) (param $value i32) - local.get $this - local.get $value - i32.store offset=4 - ) - (func $"~lib/map/Map#get:entriesOffset" (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $"~lib/map/Map#get:entriesCapacity" (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $"~lib/map/Map#get:entriesCount" (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $"~lib/map/Map#get:entries" (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#set:key" (param $this i32) (param $key i32) - local.get $this - local.get $key - i32.store - ) - (func $"~lib/map/MapEntry#set:taggedNext" (param $this i32) (param $taggedNext i32) - local.get $this - local.get $taggedNext - i32.store offset=8 - ) - (func $"~lib/map/Map#set:buckets" (param $this i32) (param $buckets i32) - local.get $this - local.get $buckets - i32.store - local.get $this - local.get $buckets - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $"~lib/map/Map#set:bucketsMask" (param $this i32) (param $bucketsMask i32) - local.get $this - local.get $bucketsMask - i32.store offset=4 - ) - (func $"~lib/map/Map#set:entries" (param $this i32) (param $entries i32) - local.get $this - local.get $entries - i32.store offset=8 - local.get $this - local.get $entries - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $"~lib/map/Map#set:entriesCapacity" (param $this i32) (param $entriesCapacity i32) - local.get $this - local.get $entriesCapacity - i32.store offset=12 - ) - (func $"~lib/map/Map#set:entriesOffset" (param $this i32) (param $entriesOffset i32) - local.get $this - local.get $entriesOffset - i32.store offset=16 - ) - (func $"~lib/map/Map#set:entriesCount" (param $this i32) (param $entriesCount i32) - local.get $this - local.get $entriesCount - i32.store offset=20 - ) - (func $assembly/memory/Memory#set:lastAllocatedPage (param $this i32) (param $lastAllocatedPage i32) - local.get $this - local.get $lastAllocatedPage - i32.store - ) - (func $start:assembly/instructions-exe - (local $0 i32) - call $start:assembly/instructions/bit - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $start:assembly/interpreter - call $start:assembly/instructions-exe - i64.const 2 - i64.const 32 - call $~lib/math/ipow64 - global.set $assembly/interpreter/MAX_U32 - ) - (func $start:assembly/api-generic - call $start:assembly/arguments - call $start:assembly/instructions - call $start:assembly/interpreter - ) - (func $start:assembly/index - call $start:assembly/api-generic - ) - (func $assembly/codec/Decoder#set:source (param $this i32) (param $source i32) - local.get $this - local.get $source - i32.store - local.get $this - local.get $source - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/codec/Decoder#set:offset (param $this i32) (param $offset i32) - local.get $this - local.get $offset - i32.store offset=4 - ) - (func $assembly/codec/Decoder#get:offset (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/Decoder#get:source (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/util/number/decimalCount32 (param $value i32) (result i32) - local.get $value - i32.const 100000 - i32.lt_u - if - local.get $value - i32.const 100 - i32.lt_u - if - i32.const 1 - local.get $value - i32.const 10 - i32.ge_u - i32.add - return - else - i32.const 3 - local.get $value - i32.const 10000 - i32.ge_u - i32.add - local.get $value - i32.const 1000 - i32.ge_u - i32.add - return - end - unreachable - else - local.get $value - i32.const 10000000 - i32.lt_u - if - i32.const 6 - local.get $value - i32.const 1000000 - i32.ge_u - i32.add - return - else - i32.const 8 - local.get $value - i32.const 1000000000 - i32.ge_u - i32.add - local.get $value - i32.const 100000000 - i32.ge_u - i32.add - return - end - unreachable - end - unreachable - ) - (func $~lib/util/number/utoa32_dec_lut (param $buffer i32) (param $num i32) (param $offset i32) - (local $t i32) - (local $r i32) - (local $d1 i32) - (local $d2 i32) - (local $digits1 i64) - (local $digits2 i64) - (local $t|9 i32) - (local $d1|10 i32) - (local $digits i32) - (local $digits|12 i32) - (local $digit i32) - loop $while-continue|0 - local.get $num - i32.const 10000 - i32.ge_u - if - local.get $num - i32.const 10000 - i32.div_u - local.set $t - local.get $num - i32.const 10000 - i32.rem_u - local.set $r - local.get $t - local.set $num - local.get $r - i32.const 100 - i32.div_u - local.set $d1 - local.get $r - i32.const 100 - i32.rem_u - local.set $d2 - i32.const 14812 - local.get $d1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 14812 - local.get $d2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $num - i32.const 100 - i32.ge_u - if - local.get $num - i32.const 100 - i32.div_u - local.set $t|9 - local.get $num - i32.const 100 - i32.rem_u - local.set $d1|10 - local.get $t|9 - local.set $num - local.get $offset - i32.const 2 - i32.sub - local.set $offset - i32.const 14812 - local.get $d1|10 - i32.const 2 - i32.shl - i32.add - i32.load - local.set $digits - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits - i32.store - end - local.get $num - i32.const 10 - i32.ge_u - if - local.get $offset - i32.const 2 - i32.sub - local.set $offset - i32.const 14812 - local.get $num - i32.const 2 - i32.shl - i32.add - i32.load - local.set $digits|12 - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits|12 - i32.store - else - local.get $offset - i32.const 1 - i32.sub - local.set $offset - i32.const 48 - local.get $num - i32.add - local.set $digit - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digit - i32.store16 - end - ) - (func $~lib/util/number/utoa_hex_lut (param $buffer i32) (param $num i64) (param $offset i32) - loop $while-continue|0 - local.get $offset - i32.const 2 - i32.ge_u - if - local.get $offset - i32.const 2 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 15232 - local.get $num - i32.wrap_i64 - i32.const 255 - i32.and - i32.const 2 - i32.shl - i32.add - i32.load - i32.store - local.get $num - i64.const 8 - i64.shr_u - local.set $num - br $while-continue|0 - end - end - local.get $offset - i32.const 1 - i32.and - if - local.get $buffer - i32.const 15232 - local.get $num - i32.wrap_i64 - i32.const 6 - i32.shl - i32.add - i32.load16_u - i32.store16 - end - ) - (func $~lib/util/number/ulog_base (param $num i64) (param $base i32) (result i32) - (local $value i32) - (local $b64 i64) - (local $b i64) - (local $e i32) - block $~lib/util/number/isPowerOf2|inlined.0 (result i32) - local.get $base - local.set $value - local.get $value - i32.popcnt - i32.const 1 - i32.eq - br $~lib/util/number/isPowerOf2|inlined.0 - end - if - i32.const 63 - local.get $num - i64.clz - i32.wrap_i64 - i32.sub - i32.const 31 - local.get $base - i32.clz - i32.sub - i32.div_u - i32.const 1 - i32.add - return - end - local.get $base - i64.extend_i32_s - local.set $b64 - local.get $b64 - local.set $b - i32.const 1 - local.set $e - loop $while-continue|0 - local.get $num - local.get $b - i64.ge_u - if - local.get $num - local.get $b - i64.div_u - local.set $num - local.get $b - local.get $b - i64.mul - local.set $b - local.get $e - i32.const 1 - i32.shl - local.set $e - br $while-continue|0 - end - end - loop $while-continue|1 - local.get $num - i64.const 1 - i64.ge_u - if - local.get $num - local.get $b64 - i64.div_u - local.set $num - local.get $e - i32.const 1 - i32.add - local.set $e - br $while-continue|1 - end - end - local.get $e - i32.const 1 - i32.sub - return - ) - (func $~lib/util/number/utoa64_any_core (param $buffer i32) (param $num i64) (param $offset i32) (param $radix i32) - (local $base i64) - (local $shift i64) - (local $mask i64) - (local $q i64) - local.get $radix - i64.extend_i32_s - local.set $base - local.get $radix - local.get $radix - i32.const 1 - i32.sub - i32.and - i32.const 0 - i32.eq - if - local.get $radix - i32.ctz - i32.const 7 - i32.and - i64.extend_i32_s - local.set $shift - local.get $base - i64.const 1 - i64.sub - local.set $mask - loop $do-loop|0 - local.get $offset - i32.const 1 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 16288 - local.get $num - local.get $mask - i64.and - i32.wrap_i64 - i32.const 1 - i32.shl - i32.add - i32.load16_u - i32.store16 - local.get $num - local.get $shift - i64.shr_u - local.set $num - local.get $num - i64.const 0 - i64.ne - br_if $do-loop|0 - end - else - loop $do-loop|1 - local.get $offset - i32.const 1 - i32.sub - local.set $offset - local.get $num - local.get $base - i64.div_u - local.set $q - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 16288 - local.get $num - local.get $q - local.get $base - i64.mul - i64.sub - i32.wrap_i64 - i32.const 1 - i32.shl - i32.add - i32.load16_u - i32.store16 - local.get $q - local.set $num - local.get $num - i64.const 0 - i64.ne - br_if $do-loop|1 - end - end - ) - (func $~lib/number/U32#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/utoa32 - return - ) - (func $~lib/number/I32#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/itoa32 - return - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/string/String#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 1 - i32.shr_u - return - ) - (func $assembly/codec/ValOffset#set:value (param $this i32) (param $value i32) - local.get $this - local.get $value - i32.store - ) - (func $assembly/codec/ValOffset#set:offset (param $this i32) (param $offset i32) - local.get $this - local.get $offset - i32.store offset=4 - ) - (func $assembly/codec/ValOffset#get:offset (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/ValOffset#get:value (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/CodeAndMetadata#set:code (param $this i32) (param $code i32) - local.get $this - local.get $code - i32.store - local.get $this - local.get $code - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/CodeAndMetadata#set:metadata (param $this i32) (param $metadata i32) - local.get $this - local.get $metadata - i32.store offset=4 - local.get $this - local.get $metadata - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/CodeAndMetadata#get:code (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/CodeAndMetadata#get:metadata (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/number/U8#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - i32.const 255 - i32.and - local.get $radix - call $~lib/util/number/utoa32 - return - ) - (func $~lib/memory/memory.repeat (param $dst i32) (param $src i32) (param $srcLength i32) (param $count i32) - (local $index i32) - (local $total i32) - i32.const 0 - local.set $index - local.get $srcLength - local.get $count - i32.mul - local.set $total - loop $while-continue|0 - local.get $index - local.get $total - i32.lt_u - if - local.get $dst - local.get $index - i32.add - local.get $src - local.get $srcLength - memory.copy - local.get $index - local.get $srcLength - i32.add - local.set $index - br $while-continue|0 - end - end - ) - (func $assembly/program/Mask#set:bytesToSkip (param $this i32) (param $bytesToSkip i32) - local.get $this - local.get $bytesToSkip - i32.store - local.get $this - local.get $bytesToSkip - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Mask#get:bytesToSkip (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - ) - (func $assembly/program/JumpTable#set:jumps (param $this i32) (param $jumps i32) - local.get $this - local.get $jumps - i32.store - local.get $this - local.get $jumps - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - ) - (func $assembly/instructions/Instruction#get:isTerminating (param $this i32) (result i32) - local.get $this - i32.load8_u offset=16 - ) - (func $assembly/program/BasicBlocks#set:isStartOrEnd (param $this i32) (param $isStartOrEnd i32) - local.get $this - local.get $isStartOrEnd - i32.store - local.get $this - local.get $isStartOrEnd - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:code (param $this i32) (param $code i32) - local.get $this - local.get $code - i32.store - local.get $this - local.get $code - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:mask (param $this i32) (param $mask i32) - local.get $this - local.get $mask - i32.store offset=4 - local.get $this - local.get $mask - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:jumpTable (param $this i32) (param $jumpTable i32) - local.get $this - local.get $jumpTable - i32.store offset=8 - local.get $this - local.get $jumpTable - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:basicBlocks (param $this i32) (param $basicBlocks i32) - local.get $this - local.get $basicBlocks - i32.store offset=12 - local.get $this - local.get $basicBlocks - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#get:code (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/Program#get:mask (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/Instruction#get:namePtr (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/instructions/Instruction#get:kind (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i64) (param $start i32) (param $end i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $start - i32.add - local.tee $5 - i32.const 0 - local.tee $6 - local.get $5 - local.get $6 - i32.gt_u - select - else - local.get $start - local.tee $7 - local.get $len - local.tee $8 - local.get $7 - local.get $8 - i32.lt_s - select - end - local.set $start - local.get $end - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $end - i32.add - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_u - select - else - local.get $end - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - end - local.set $end - i32.const 8 - i32.const 1 - i32.eq - drop - i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 1 - drop - local.get $value - i64.const 0 - i64.eq - local.get $value - i64.const -1 - i64.eq - i32.or - if - local.get $start - local.get $end - i32.lt_s - if - local.get $ptr - local.get $start - i32.const 3 - i32.shl - i32.add - local.get $value - i32.wrap_i64 - local.get $end - local.get $start - i32.sub - i32.const 3 - i32.shl - memory.fill - end - return - end - loop $for-loop|0 - local.get $start - local.get $end - i32.lt_s - if - local.get $ptr - local.get $start - i32.const 3 - i32.shl - i32.add - local.get $value - i64.store - local.get $start - i32.const 1 - i32.add - local.set $start - br $for-loop|0 - end - end - ) - (func $assembly/api-generic/VmInput#set:registers (param $this i32) (param $registers i32) - local.get $this - local.get $registers - i32.store - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmInput#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store offset=4 - ) - (func $assembly/api-generic/VmInput#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/api-generic/VmInput#set:program (param $this i32) (param $program i32) - local.get $this - local.get $program - i32.store offset=16 - local.get $this - local.get $program - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmInput#set:pageMap (param $this i32) (param $pageMap i32) - local.get $this - local.get $pageMap - i32.store offset=20 - local.get $this - local.get $pageMap - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmInput#set:memory (param $this i32) (param $memory i32) - local.get $this - local.get $memory - i32.store offset=24 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmInput#get:program (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $assembly/api-generic/VmInput#get:registers (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/MemoryBuilder#set:pages (param $this i32) (param $pages i32) - local.get $this - local.get $pages - i32.store - local.get $this - local.get $pages - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/Arena#set:arenaBytes (param $this i32) (param $arenaBytes i32) - local.get $this - local.get $arenaBytes - i32.store offset=4 - ) - (func $assembly/memory-page/Arena#set:free (param $this i32) (param $free i32) - local.get $this - local.get $free - i32.store - local.get $this - local.get $free - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/arraybuffer/ArrayBuffer#get:byteLength (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - return - ) - (func $assembly/memory/MemoryBuilder#set:arena (param $this i32) (param $arena i32) - local.get $this - local.get $arena - i32.store offset=4 - local.get $this - local.get $arena - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmInput#get:pageMap (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $assembly/api-generic/VmInput#get:memory (param $this i32) (result i32) - local.get $this - i32.load offset=24 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/api-generic/InitialPage#get:access (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/api-generic/InitialPage#get:address (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/api-generic/InitialPage#get:length (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/MemoryBuilder#get:pages (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/MemoryBuilder#get:arena (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/api-generic/InitialChunk#get:data (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/api-generic/InitialChunk#get:address (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/Memory#set:arena (param $this i32) (param $arena i32) - local.get $this - local.get $arena - i32.store offset=4 - local.get $this - local.get $arena - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#set:pages (param $this i32) (param $pages i32) - local.get $this - local.get $pages - i32.store offset=8 - local.get $this - local.get $pages - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/interpreter/Interpreter#set:program (param $this i32) (param $program i32) - local.get $this - local.get $program - i32.store - local.get $this - local.get $program - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/interpreter/Interpreter#set:registers (param $this i32) (param $registers i32) - local.get $this - local.get $registers - i32.store offset=4 - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/interpreter/Interpreter#set:memory (param $this i32) (param $memory i32) - local.get $this - local.get $memory - i32.store offset=8 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/gas/GasCounterU64#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store - ) - (func $assembly/gas/gasCounter (param $gas i64) (result i32) - i32.const 0 - local.get $gas - call $assembly/gas/GasCounterU64#constructor - return - ) - (func $assembly/interpreter/Interpreter#set:gas (param $this i32) (param $gas i32) - local.get $this - local.get $gas - i32.store offset=12 - local.get $this - local.get $gas - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/interpreter/Interpreter#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store offset=16 - ) - (func $assembly/interpreter/Interpreter#set:status (param $this i32) (param $status i32) - local.get $this - local.get $status - i32.store offset=20 - ) - (func $assembly/interpreter/Interpreter#set:exitCode (param $this i32) (param $exitCode i32) - local.get $this - local.get $exitCode - i32.store offset=24 - ) - (func $assembly/interpreter/Interpreter#set:nextPc (param $this i32) (param $nextPc i32) - local.get $this - local.get $nextPc - i32.store offset=28 - ) - (func $assembly/interpreter/Interpreter#set:useSbrkGas (param $this i32) (param $useSbrkGas i32) - local.get $this - local.get $useSbrkGas - i32.store8 offset=32 - ) - (func $assembly/api-generic/VmInput#get:pc (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/interpreter/Interpreter#get:gas (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/api-generic/VmInput#get:gas (param $this i32) (result i64) - local.get $this - i64.load offset=8 - ) - (func $assembly/gas/GasCounter#set (param $this i32) (param $g i64) - unreachable - ) - (func $~lib/util/number/decimalCount64High (param $value i64) (result i32) - local.get $value - i64.const 1000000000000000 - i64.lt_u - if - local.get $value - i64.const 1000000000000 - i64.lt_u - if - i32.const 10 - local.get $value - i64.const 100000000000 - i64.ge_u - i32.add - local.get $value - i64.const 10000000000 - i64.ge_u - i32.add - return - else - i32.const 13 - local.get $value - i64.const 100000000000000 - i64.ge_u - i32.add - local.get $value - i64.const 10000000000000 - i64.ge_u - i32.add - return - end - unreachable - else - local.get $value - i64.const 100000000000000000 - i64.lt_u - if - i32.const 16 - local.get $value - i64.const 10000000000000000 - i64.ge_u - i32.add - return - else - i32.const 18 - local.get $value - i64.const -8446744073709551616 - i64.ge_u - i32.add - local.get $value - i64.const 1000000000000000000 - i64.ge_u - i32.add - return - end - unreachable - end - unreachable - ) - (func $~lib/util/number/utoa64_dec_lut (param $buffer i32) (param $num i64) (param $offset i32) - (local $t i64) - (local $r i32) - (local $b i32) - (local $c i32) - (local $b1 i32) - (local $b2 i32) - (local $c1 i32) - (local $c2 i32) - (local $digits1 i64) - (local $digits2 i64) - loop $while-continue|0 - local.get $num - i64.const 100000000 - i64.ge_u - if - local.get $num - i64.const 100000000 - i64.div_u - local.set $t - local.get $num - local.get $t - i64.const 100000000 - i64.mul - i64.sub - i32.wrap_i64 - local.set $r - local.get $t - local.set $num - local.get $r - i32.const 10000 - i32.div_u - local.set $b - local.get $r - i32.const 10000 - i32.rem_u - local.set $c - local.get $b - i32.const 100 - i32.div_u - local.set $b1 - local.get $b - i32.const 100 - i32.rem_u - local.set $b2 - local.get $c - i32.const 100 - i32.div_u - local.set $c1 - local.get $c - i32.const 100 - i32.rem_u - local.set $c2 - i32.const 14812 - local.get $c1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 14812 - local.get $c2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - i32.const 14812 - local.get $b1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 14812 - local.get $b2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $buffer - local.get $num - i32.wrap_i64 - local.get $offset - call $~lib/util/number/utoa32_dec_lut - ) - (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i64) (result i32) - (local $sign i32) - (local $dest i32) - (local $decimals i32) - (local $val32 i32) - (local $buffer|6 i32) - (local $num i32) - (local $offset i32) - (local $val64 i64) - (local $buffer|10 i32) - (local $num|11 i64) - (local $offset|12 i32) - i32.const 0 - local.set $sign - i32.const 0 - drop - local.get $buffer - local.get $sign - i32.const 1 - i32.shl - i32.add - local.set $dest - i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 0 - drop - local.get $value - i64.const 10 - i64.lt_u - if - local.get $buffer - local.get $value - i32.const 48 - i64.extend_i32_s - i64.or - i64.store16 - i32.const 1 - return - end - i32.const 0 - local.set $decimals - i32.const 8 - i32.const 4 - i32.le_u - drop - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - local.get $dest - local.set $buffer|6 - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|6 - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - local.set $val64 - local.get $val64 - call $~lib/util/number/decimalCount64High - local.set $decimals - local.get $dest - local.set $buffer|10 - local.get $val64 - local.set $num|11 - local.get $decimals - local.set $offset|12 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|10 - local.get $num|11 - local.get $offset|12 - call $~lib/util/number/utoa64_dec_lut - end - local.get $sign - local.get $decimals - i32.add - return - ) - (func $~lib/number/U64#toString (param $this i64) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/utoa64 - return - ) - (func $~lib/array/Array<~lib/string/String>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array<~lib/string/String>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/interpreter/Interpreter#get:status (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $assembly/interpreter/Interpreter#get:pc (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $assembly/interpreter/Interpreter#get:program (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/interpreter/Interpreter#get:registers (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/program/ResolvedArguments#set:a (param $this i32) (param $a i64) - local.get $this - local.get $a - i64.store - ) - (func $assembly/program/ResolvedArguments#set:b (param $this i32) (param $b i64) - local.get $this - local.get $b - i64.store offset=8 - ) - (func $assembly/program/ResolvedArguments#set:c (param $this i32) (param $c i64) - local.get $this - local.get $c - i64.store offset=16 - ) - (func $assembly/program/ResolvedArguments#set:d (param $this i32) (param $d i64) - local.get $this - local.get $d - i64.store offset=24 - ) - (func $assembly/program/ResolvedArguments#set:decoded (param $this i32) (param $decoded i32) - local.get $this - local.get $decoded - i32.store offset=32 - local.get $this - local.get $decoded - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/ResolvedArguments#get:a (param $this i32) (result i64) - local.get $this - i64.load - ) - (func $~lib/number/I64#toString (param $this i64) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/itoa64 - return - ) - (func $assembly/program/ResolvedArguments#get:decoded (param $this i32) (result i32) - local.get $this - i32.load offset=32 - ) - (func $assembly/program/ResolvedArguments#get:b (param $this i32) (result i64) - local.get $this - i64.load offset=8 - ) - (func $assembly/program/ResolvedArguments#get:c (param $this i32) (result i64) - local.get $this - i64.load offset=16 - ) - (func $assembly/program/ResolvedArguments#get:d (param $this i32) (result i64) - local.get $this - i64.load offset=24 - ) - (func $assembly/interpreter/Interpreter#get:nextPc (param $this i32) (result i32) - local.get $this - i32.load offset=28 - ) - (func $assembly/instructions/Instruction#get:gas (param $this i32) (result i64) - local.get $this - i64.load offset=8 - ) - (func $assembly/gas/GasCounter#sub (param $this i32) (param $g i64) (result i32) - unreachable - ) - (func $assembly/interpreter/Interpreter#get:useSbrkGas (param $this i32) (result i32) - local.get $this - i32.load8_u offset=32 - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/interpreter/Interpreter#get:memory (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/instructions/outcome/OutcomeData#get:outcome (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/Program#get:jumpTable (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/instructions/outcome/OutcomeData#get:dJump (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/interpreter/DjumpResult#set:status (param $this i32) (param $status i32) - local.get $this - local.get $status - i32.store - ) - (func $assembly/interpreter/DjumpResult#set:newPc (param $this i32) (param $newPc i32) - local.get $this - local.get $newPc - i32.store offset=4 - ) - (func $assembly/program/JumpTable#get:jumps (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/interpreter/DjumpResult#get:status (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/Program#get:basicBlocks (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/interpreter/DjumpResult#get:newPc (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/interpreter/BranchResult#set:isOkay (param $this i32) (param $isOkay i32) - local.get $this - local.get $isOkay - i32.store8 - ) - (func $assembly/interpreter/BranchResult#set:newPc (param $this i32) (param $newPc i32) - local.get $this - local.get $newPc - i32.store offset=4 - ) - (func $assembly/program/BasicBlocks#get:isStartOrEnd (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/interpreter/BranchResult#get:isOkay (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $assembly/interpreter/BranchResult#get:newPc (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/outcome/OutcomeData#get:staticJump (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/outcome/OutcomeData#get:result (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/instructions/outcome/OutcomeData#get:exitCode (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $assembly/api-generic/VmOutput#set:status (param $this i32) (param $status i32) - local.get $this - local.get $status - i32.store - ) - (func $assembly/api-generic/VmOutput#set:registers (param $this i32) (param $registers i32) - local.get $this - local.get $registers - i32.store offset=4 - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmOutput#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store offset=8 - ) - (func $assembly/api-generic/VmOutput#set:memory (param $this i32) (param $memory i32) - local.get $this - local.get $memory - i32.store offset=12 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmOutput#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=16 - ) - (func $assembly/api-generic/VmOutput#set:exitCode (param $this i32) (param $exitCode i32) - local.get $this - local.get $exitCode - i32.store offset=24 - ) - (func $assembly/gas/GasCounter#get (param $this i32) (result i64) - unreachable - ) - (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $assembly/api-generic/InitialChunk#set:address (param $this i32) (param $address i32) - local.get $this - local.get $address - i32.store - ) - (func $assembly/api-generic/InitialChunk#set:data (param $this i32) (param $data i32) - local.get $this - local.get $data - i32.store offset=4 - local.get $this - local.get $data - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $assembly/interpreter/Interpreter#get:exitCode (param $this i32) (result i32) - local.get $this - i32.load offset=24 - ) - (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/api-generic/VmOutput#get:status (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 0 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - i32.const 0 - drop - ) - (func $assembly/program-build/immBytes (param $dataLength i32) (param $required i32) (result i32) - (local $value1 f64) - (local $value2 f64) - local.get $dataLength - local.get $required - i32.lt_s - if - i32.const 0 - return - end - block $~lib/math/NativeMath.min|inlined.4 (result f64) - f64.const 4 - local.set $value1 - local.get $dataLength - local.get $required - i32.sub - f64.convert_i32_s - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.4 - end - i32.trunc_sat_f64_s - return - ) - (func $~lib/dataview/DataView#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/dataview/DataView#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/dataview/DataView#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $~lib/dataview/DataView#get:byteLength (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/dataview/DataView#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/api-generic/InitialPage#set:address (param $this i32) (param $address i32) - local.get $this - local.get $address - i32.store - ) - (func $assembly/api-generic/InitialPage#set:length (param $this i32) (param $length i32) - local.get $this - local.get $length - i32.store offset=4 - ) - (func $assembly/api-generic/InitialPage#set:access (param $this i32) (param $access i32) - local.get $this - local.get $access - i32.store offset=8 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/rt/itcms/__pin (param $ptr i32) (result i32) - (local $obj i32) - local.get $ptr - if - local.get $ptr - i32.const 20 - i32.sub - local.set $obj - local.get $obj - call $~lib/rt/itcms/Object#get:color - i32.const 3 - i32.eq - if - i32.const 19920 - i32.const 352 - i32.const 338 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $obj - call $~lib/rt/itcms/Object#unlink - local.get $obj - global.get $~lib/rt/itcms/pinSpace - i32.const 3 - call $~lib/rt/itcms/Object#linkTo - end - local.get $ptr - return - ) - (func $~lib/rt/itcms/__unpin (param $ptr i32) - (local $obj i32) - local.get $ptr - i32.eqz - if - return - end - local.get $ptr - i32.const 20 - i32.sub - local.set $obj - local.get $obj - call $~lib/rt/itcms/Object#get:color - i32.const 3 - i32.ne - if - i32.const 19984 - i32.const 352 - i32.const 352 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/state - i32.const 1 - i32.eq - if - local.get $obj - call $~lib/rt/itcms/Object#makeGray - else - local.get $obj - call $~lib/rt/itcms/Object#unlink - local.get $obj - global.get $~lib/rt/itcms/fromSpace - global.get $~lib/rt/itcms/white - call $~lib/rt/itcms/Object#linkTo - end - ) - (func $~lib/rt/itcms/__collect - i32.const 0 - drop - global.get $~lib/rt/itcms/state - i32.const 0 - i32.gt_s - if - loop $while-continue|0 - global.get $~lib/rt/itcms/state - i32.const 0 - i32.ne - if - call $~lib/rt/itcms/step - drop - br $while-continue|0 - end - end - end - call $~lib/rt/itcms/step - drop - loop $while-continue|1 - global.get $~lib/rt/itcms/state - i32.const 0 - i32.ne - if - call $~lib/rt/itcms/step - drop - br $while-continue|1 - end - end - global.get $~lib/rt/itcms/total - i64.extend_i32_u - i32.const 200 - i64.extend_i32_u - i64.mul - i64.const 100 - i64.div_u - i32.wrap_i64 - i32.const 1024 - i32.add - global.set $~lib/rt/itcms/threshold - i32.const 0 - drop - i32.const 0 - drop - ) - (func $assembly/gas/GasCounterU64#get:gas (param $this i32) (result i64) - local.get $this - i64.load - ) - (func $assembly/gas/GasCounter#set@override (param $0 i32) (param $1 i64) - (local $2 i32) - block $default - block $case0 - local.get $0 - i32.const 8 - i32.sub - i32.load - local.set $2 - local.get $2 - i32.const 51 - i32.eq - br_if $case0 - br $default - end - local.get $0 - local.get $1 - call $assembly/gas/GasCounterU64#set - return - end - unreachable - ) - (func $assembly/gas/GasCounter#sub@override (param $0 i32) (param $1 i64) (result i32) - (local $2 i32) - block $default - block $case0 - local.get $0 - i32.const 8 - i32.sub - i32.load - local.set $2 - local.get $2 - i32.const 51 - i32.eq - br_if $case0 - br $default - end - local.get $0 - local.get $1 - call $assembly/gas/GasCounterU64#sub - return - end - unreachable - ) - (func $assembly/gas/GasCounter#get@override (param $0 i32) (result i64) - (local $1 i32) - block $default - block $case0 - local.get $0 - i32.const 8 - i32.sub - i32.load - local.set $1 - local.get $1 - i32.const 51 - i32.eq - br_if $case0 - br $default - end - local.get $0 - call $assembly/gas/GasCounterU64#get - return - end - unreachable - ) - (func $~lib/rt/__visit_globals (param $0 i32) - (local $1 i32) - i32.const 480 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 8176 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 13120 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 16800 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 9376 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 288 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 19920 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 19984 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 15232 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 16288 - local.get $0 - call $~lib/rt/itcms/__visit - global.get $assembly/api/interpreter - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/RELEVANT_ARGS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/REQUIRED_BYTES - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/DECODERS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/INSTRUCTIONS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_PAGE - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/codec/MASKS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions-exe/RUN - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - ) - (func $~lib/arraybuffer/ArrayBufferView~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/object/Object~visit (param $0 i32) (param $1 i32) - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/typedarray/Uint8Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/memory-page/Page~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory-page/RawPage~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/Memory~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory-page/Arena~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $"~lib/map/Map~visit" (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $"~lib/map/Map#__visit" - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit - ) - (func $assembly/memory/Result~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/ChunkBytes~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/Chunks~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/PageData~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/function/Function<%28u8%29=>u8>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28u8%29=>u8>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28u8%29=>u8>#__visit - ) - (func $assembly/interpreter/Interpreter~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/Program~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/Mask~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/JumpTable~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/BasicBlocks~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/CodeAndMetadata~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/codec/Decoder~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - i32.const 1 - drop - local.get $this - local.set $cur - local.get $cur - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray<~lib/string/String>#__visit - ) - (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/api-generic/VmOutput~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/api-generic/InitialChunk~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/api-generic/VmInput~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=16 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=20 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=24 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/memory/MemoryBuilder~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array<~lib/string/String>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<~lib/string/String>#__visit - ) - (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit - ) - (func $assembly/program/ResolvedArguments~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=32 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/dataview/DataView~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/rt/__visit_members (param $0 i32) (param $1 i32) - block $invalid - block $~lib/dataview/DataView - block $~lib/staticarray/StaticArray - block $~lib/array/Array - block $assembly/interpreter/BranchResult - block $assembly/interpreter/DjumpResult - block $assembly/program/ResolvedArguments - block $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> - block $~lib/array/Array<~lib/string/String> - block $assembly/gas/GasCounterU64 - block $assembly/memory/MemoryBuilder - block $~lib/array/Array - block $assembly/api-generic/InitialPage - block $assembly/api-generic/VmInput - block $~lib/array/Array - block $assembly/api-generic/InitialChunk - block $assembly/api-generic/VmOutput - block $~lib/array/Array - block $~lib/array/Array - block $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> - block $assembly/codec/ValOffset - block $~lib/staticarray/StaticArray<~lib/string/String> - block $assembly/codec/Decoder - block $assembly/program/CodeAndMetadata - block $assembly/gas/GasCounter - block $~lib/staticarray/StaticArray - block $assembly/program/BasicBlocks - block $assembly/program/JumpTable - block $~lib/staticarray/StaticArray - block $assembly/program/Mask - block $assembly/program/Program - block $assembly/interpreter/Interpreter - block $~lib/function/Function<%28u8%29=>u8> - block $~lib/array/Array - block $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> - block $assembly/memory/PageData - block $assembly/memory/Chunks - block $~lib/staticarray/StaticArray - block $assembly/memory/ChunkBytes - block $assembly/memory/Result - block $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> - block $assembly/instructions/outcome/OutcomeData - block $"~lib/map/Map" - block $~lib/array/Array - block $assembly/memory-page/Arena - block $assembly/memory/Memory - block $~lib/staticarray/StaticArray - block $assembly/memory-page/RawPage - block $assembly/memory-page/Page - block $assembly/memory/MaybePageFault - block $~lib/array/Array - block $assembly/arguments/Nibbles - block $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> - block $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> - block $assembly/arguments/Args - block $~lib/typedarray/Uint8Array - block $~lib/array/Array - block $~lib/arraybuffer/ArrayBufferView - block $~lib/string/String - block $~lib/arraybuffer/ArrayBuffer - block $~lib/object/Object - local.get $0 - i32.const 8 - i32.sub - i32.load - br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $~lib/arraybuffer/ArrayBufferView $~lib/array/Array $~lib/typedarray/Uint8Array $assembly/arguments/Args $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $assembly/arguments/Nibbles $~lib/array/Array $assembly/memory/MaybePageFault $assembly/memory-page/Page $assembly/memory-page/RawPage $~lib/staticarray/StaticArray $assembly/memory/Memory $assembly/memory-page/Arena $~lib/array/Array $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $assembly/memory/Result $assembly/memory/ChunkBytes $~lib/staticarray/StaticArray $assembly/memory/Chunks $assembly/memory/PageData $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $~lib/array/Array $~lib/function/Function<%28u8%29=>u8> $assembly/interpreter/Interpreter $assembly/program/Program $assembly/program/Mask $~lib/staticarray/StaticArray $assembly/program/JumpTable $assembly/program/BasicBlocks $~lib/staticarray/StaticArray $assembly/gas/GasCounter $assembly/program/CodeAndMetadata $assembly/codec/Decoder $~lib/staticarray/StaticArray<~lib/string/String> $assembly/codec/ValOffset $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> $~lib/array/Array $~lib/array/Array $assembly/api-generic/VmOutput $assembly/api-generic/InitialChunk $~lib/array/Array $assembly/api-generic/VmInput $assembly/api-generic/InitialPage $~lib/array/Array $assembly/memory/MemoryBuilder $assembly/gas/GasCounterU64 $~lib/array/Array<~lib/string/String> $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> $assembly/program/ResolvedArguments $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $~lib/array/Array $~lib/staticarray/StaticArray $~lib/dataview/DataView $invalid - end - return - end - return - end - return - end - local.get $0 - local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/typedarray/Uint8Array~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/Page~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/RawPage~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory/Memory~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/Arena~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $"~lib/map/Map~visit" - return - end - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/Result~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/ChunkBytes~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory/Chunks~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/PageData~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28u8%29=>u8>~visit - return - end - local.get $0 - local.get $1 - call $assembly/interpreter/Interpreter~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/Program~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/Mask~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/program/JumpTable~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/BasicBlocks~visit - return - end - return - end - return - end - local.get $0 - local.get $1 - call $assembly/program/CodeAndMetadata~visit - return - end - local.get $0 - local.get $1 - call $assembly/codec/Decoder~visit - return - end - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray<~lib/string/String>~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $assembly/api-generic/VmOutput~visit - return - end - local.get $0 - local.get $1 - call $assembly/api-generic/InitialChunk~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $assembly/api-generic/VmInput~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/MemoryBuilder~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/ResolvedArguments~visit - return - end - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/dataview/DataView~visit - return - end - unreachable - ) - (func $~setArgumentsLength (param $0 i32) - local.get $0 - global.set $~argumentsLength - ) - (func $~start - call $start:assembly/index - ) - (func $~stack_check - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__data_end - i32.lt_s - if - i32.const 53072 - i32.const 53120 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - ) - (func $assembly/arguments/Args#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 6 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:b - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:c - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:d - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/arguments/Args.from (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32) - (local $x i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $x - i32.store - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $a - call $assembly/arguments/Args#set:a - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $b - call $assembly/arguments/Args#set:b - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $c - call $assembly/arguments/Args#set:c - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $d - call $assembly/arguments/Args#set:d - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/typedarray/Uint8Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/typedarray/Uint8Array#subarray (param $this i32) (param $begin i32) (param $end i32) (result i32) - (local $array i32) - (local $begin|4 i32) - (local $end|5 i32) - (local $len i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $14 i32) - (local $15 i32) - (local $16 i32) - (local $out i32) - (local $buf i32) - (local $19 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - block $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $array - i32.store - local.get $begin - local.set $begin|4 - local.get $end - local.set $end|5 - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - local.get $begin|4 - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $begin|4 - i32.add - local.tee $7 - i32.const 0 - local.tee $8 - local.get $7 - local.get $8 - i32.gt_s - select - else - local.get $begin|4 - local.tee $9 - local.get $len - local.tee $10 - local.get $9 - local.get $10 - i32.lt_s - select - end - local.set $begin|4 - local.get $end|5 - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $end|5 - i32.add - local.tee $11 - i32.const 0 - local.tee $12 - local.get $11 - local.get $12 - i32.gt_s - select - else - local.get $end|5 - local.tee $13 - local.get $len - local.tee $14 - local.get $13 - local.get $14 - i32.lt_s - select - end - local.set $end|5 - local.get $end|5 - local.tee $15 - local.get $begin|4 - local.tee $16 - local.get $15 - local.get $16 - i32.gt_s - select - local.set $end|5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=8 - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $buf - local.get $out - local.get $buf - i32.store - local.get $out - local.get $buf - i32.const 0 - call $~lib/rt/itcms/__link - local.get $out - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $begin|4 - i32.const 0 - i32.shl - i32.add - i32.store offset=4 - local.get $out - local.get $end|5 - local.get $begin|4 - i32.sub - i32.const 0 - i32.shl - i32.store offset=8 - local.get $out - br $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" - end - local.set $19 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $19 - return - ) - (func $~lib/typedarray/Uint8Array#__get (param $this i32) (param $index i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - i32.ge_u - if - i32.const 480 - i32.const 720 - i32.const 167 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $index - i32.add - i32.load8_u - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/arguments/decodeI32 (param $input i32) (param $start i32) (param $end i32) (result i32) - (local $data i32) - (local $value1 f64) - (local $value2 f64) - (local $len i32) - (local $num i32) - (local $i i32) - (local $msb i32) - (local $prefix i32) - (local $i|11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $input - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $start - local.get $end - local.get $start - i32.gt_u - if (result i32) - local.get $end - else - local.get $start - end - call $~lib/typedarray/Uint8Array#subarray - local.tee $data - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.0 (result f64) - f64.const 4 - local.set $value1 - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.0 - end - i32.trunc_sat_f64_u - local.set $len - i32.const 0 - local.set $num - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_u - if - local.get $num - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.get $i - i32.const 8 - i32.mul - i32.shl - i32.or - local.set $num - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $len - i32.const 0 - i32.gt_u - if (result i32) - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $len - i32.const 1 - i32.sub - call $~lib/typedarray/Uint8Array#__get - i32.const 128 - i32.and - else - i32.const 0 - end - local.set $msb - local.get $msb - i32.const 0 - i32.gt_u - if (result i32) - i32.const 255 - else - i32.const 0 - end - local.set $prefix - local.get $len - local.set $i|11 - loop $for-loop|1 - local.get $i|11 - i32.const 4 - i32.lt_u - if - local.get $num - local.get $prefix - local.get $i|11 - i32.const 8 - i32.mul - i32.shl - i32.or - local.set $num - local.get $i|11 - i32.const 1 - i32.add - local.set $i|11 - br $for-loop|1 - end - end - local.get $num - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $start:assembly/arguments~anonymous|1 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/arguments/Nibbles#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 2 - i32.const 9 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Nibbles#set:low - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Nibbles#set:hig - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/arguments/nibbles (param $byte i32) (result i32) - (local $low i32) - (local $hig i32) - (local $n i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $byte - i32.const 15 - i32.and - local.set $low - local.get $byte - i32.const 255 - i32.and - i32.const 4 - i32.const 7 - i32.and - i32.shr_u - local.set $hig - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Nibbles#constructor - local.tee $n - i32.store - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $low - call $assembly/arguments/Nibbles#set:low - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $hig - call $assembly/arguments/Nibbles#set:hig - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/arguments/twoImm (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $first i32) - (local $second i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.1 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.1 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $first - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $second - local.get $first - local.get $second - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|2 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $lim - call $assembly/arguments/twoImm - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $start:assembly/arguments~anonymous|3 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/arguments~anonymous|4 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/typedarray/Uint8Array#subarray@varargs (param $this i32) (param $begin i32) (param $end i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $begin - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $begin - local.get $end - call $~lib/typedarray/Uint8Array#subarray - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/arguments/decodeU32 (param $data i32) (result i32) - (local $num i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 2 - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 3 - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - local.set $num - local.get $num - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/arguments~anonymous|5 (param $data i32) (param $_lim i32) (result i32) - (local $a i32) - (local $b i32) - (local $c i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Nibbles#get:low - local.set $a - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/decodeU32 - local.set $b - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 5 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/decodeU32 - local.set $c - local.get $a - i32.const 255 - i32.and - local.get $b - local.get $c - i32.const 0 - call $assembly/arguments/Args.from - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/arguments~anonymous|6 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $immA i32) - (local $immB i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.2 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.2 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $immA - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $immB - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $immA - local.get $immB - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|7 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $immA i32) - (local $offs i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.3 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.3 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $immA - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $offs - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $immA - local.get $offs - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|8 (param $data i32) (param $_lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|9 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|10 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|11 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - i32.const 1 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $lim - i32.const 1 - i32.gt_u - if (result i32) - local.get $lim - i32.const 1 - i32.sub - else - i32.const 0 - end - call $assembly/arguments/twoImm - local.tee $result - i32.store offset=12 - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:a - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/arguments/Args.from - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/arguments~anonymous|12 (param $data i32) (param $_lim i32) (result i32) - (local $a i32) - (local $b i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $a - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $b - i32.store offset=8 - local.get $a - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $a - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $b - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - i32.const 0 - call $assembly/arguments/Args.from - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/array/ensureCapacity (param $array i32) (param $newSize i32) (param $alignLog2 i32) (param $canGrow i32) - (local $oldCapacity i32) - (local $oldData i32) - (local $6 i32) - (local $7 i32) - (local $newCapacity i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $newData i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $array - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - local.set $oldCapacity - local.get $newSize - local.get $oldCapacity - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - local.get $newSize - i32.const 1073741820 - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8128 - i32.const 19 - i32.const 48 - call $~lib/builtins/abort - unreachable - end - local.get $array - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $oldData - local.get $newSize - local.tee $6 - i32.const 8 - local.tee $7 - local.get $6 - local.get $7 - i32.gt_u - select - local.get $alignLog2 - i32.shl - local.set $newCapacity - local.get $canGrow - if - local.get $oldCapacity - i32.const 1 - i32.shl - local.tee $9 - i32.const 1073741820 - local.tee $10 - local.get $9 - local.get $10 - i32.lt_u - select - local.tee $11 - local.get $newCapacity - local.tee $12 - local.get $11 - local.get $12 - i32.gt_u - select - local.set $newCapacity - end - local.get $oldData - local.get $newCapacity - call $~lib/rt/itcms/__renew - local.set $newData - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $newData - local.get $oldData - i32.ne - if - local.get $array - local.get $newData - i32.store - local.get $array - local.get $newData - i32.store offset=4 - local.get $array - local.get $newData - i32.const 0 - call $~lib/rt/itcms/__link - end - local.get $array - local.get $newCapacity - i32.store offset=8 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 1296 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/MISSING_INSTRUCTION - i32.const 1344 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/SBRK - global.get $~lib/memory/__stack_pointer - i32.const 231 - i32.const 2 - i32.const 10 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.const 1376 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 1408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 5 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 6 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 7 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 8 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 9 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 10 - i32.const 1456 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 11 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 12 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 13 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 14 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 15 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 16 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 17 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 18 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 19 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 20 - i32.const 1488 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneExtImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 21 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 22 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 23 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 24 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 25 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 26 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 27 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 28 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 29 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 30 - i32.const 1536 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 31 - i32.const 1584 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 32 - i32.const 1632 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 33 - i32.const 1680 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 34 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 35 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 36 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 37 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 38 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 39 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 40 - i32.const 1728 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 41 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 42 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 43 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 44 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 45 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 46 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 47 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 48 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 49 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 50 - i32.const 1760 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 51 - i32.const 1808 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 52 - i32.const 1856 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 53 - i32.const 1904 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 54 - i32.const 1952 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 55 - i32.const 2000 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 56 - i32.const 2048 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 57 - i32.const 2096 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 58 - i32.const 2144 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 59 - i32.const 2192 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 60 - i32.const 2240 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 61 - i32.const 2288 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 62 - i32.const 2336 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 63 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 64 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 65 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 66 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 67 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 68 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 69 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 70 - i32.const 2384 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 71 - i32.const 2448 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 72 - i32.const 2512 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 73 - i32.const 2576 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 74 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 75 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 76 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 77 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 78 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 79 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 80 - i32.const 2640 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 81 - i32.const 2688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 82 - i32.const 2736 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 83 - i32.const 2784 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 84 - i32.const 2848 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 85 - i32.const 2912 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 86 - i32.const 2976 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 87 - i32.const 3040 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 88 - i32.const 3104 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 89 - i32.const 3168 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 90 - i32.const 3232 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 91 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 92 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 93 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 94 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 95 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 96 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 97 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 98 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 99 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 100 - i32.const 3296 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 101 - global.get $assembly/instructions/SBRK - call $~lib/array/Array#__set - local.get $0 - i32.const 102 - i32.const 3344 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 103 - i32.const 3408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 104 - i32.const 3472 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 105 - i32.const 3536 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 106 - i32.const 3600 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 107 - i32.const 3664 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 108 - i32.const 3728 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 109 - i32.const 3776 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 110 - i32.const 3824 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 111 - i32.const 3872 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 112 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 113 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 114 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 115 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 116 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 117 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 118 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 119 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 120 - i32.const 3920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 121 - i32.const 3968 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 122 - i32.const 4016 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 123 - i32.const 4064 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 124 - i32.const 4112 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 125 - i32.const 4160 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 126 - i32.const 4208 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 127 - i32.const 4256 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 128 - i32.const 4304 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 129 - i32.const 4352 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 130 - i32.const 4400 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 131 - i32.const 4448 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 132 - i32.const 4496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 133 - i32.const 4544 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 134 - i32.const 4592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 135 - i32.const 4624 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 136 - i32.const 4672 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 137 - i32.const 4720 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 138 - i32.const 4768 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 139 - i32.const 4816 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 140 - i32.const 4864 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 141 - i32.const 4912 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 142 - i32.const 4960 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 143 - i32.const 5008 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 144 - i32.const 5056 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 145 - i32.const 5120 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 146 - i32.const 5184 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 147 - i32.const 5248 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 148 - i32.const 5296 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 149 - i32.const 5344 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 150 - i32.const 5392 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 151 - i32.const 5440 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 152 - i32.const 5488 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 153 - i32.const 5536 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 154 - i32.const 5584 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 155 - i32.const 5632 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 156 - i32.const 5696 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 157 - i32.const 5760 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 158 - i32.const 5824 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 159 - i32.const 5872 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 160 - i32.const 5936 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 161 - i32.const 5984 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 162 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 163 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 164 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 165 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 166 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 167 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 168 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 169 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 170 - i32.const 6048 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 171 - i32.const 6096 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 172 - i32.const 6144 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 173 - i32.const 6192 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 174 - i32.const 6240 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 175 - i32.const 6288 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 176 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 177 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 178 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 179 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 180 - i32.const 6336 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegTwoImm - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 181 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 182 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 183 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 184 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 185 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 186 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 187 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 188 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 189 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 190 - i32.const 6400 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 191 - i32.const 6432 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 192 - i32.const 6464 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 193 - i32.const 6496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 194 - i32.const 6544 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 195 - i32.const 6592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 196 - i32.const 6640 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 197 - i32.const 6688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 198 - i32.const 6736 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 199 - i32.const 6784 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 200 - i32.const 6832 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 201 - i32.const 6864 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 202 - i32.const 6896 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 203 - i32.const 6928 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 204 - i32.const 6976 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 205 - i32.const 7024 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 206 - i32.const 7072 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 207 - i32.const 7120 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 208 - i32.const 7168 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 209 - i32.const 7216 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 210 - i32.const 7264 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 211 - i32.const 7296 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 212 - i32.const 7328 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 213 - i32.const 7360 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 214 - i32.const 7408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 215 - i32.const 7456 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 216 - i32.const 7504 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 217 - i32.const 7552 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 218 - i32.const 7600 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 219 - i32.const 7648 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 220 - i32.const 7696 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 221 - i32.const 7744 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 222 - i32.const 7792 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 223 - i32.const 7840 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 224 - i32.const 7888 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 225 - i32.const 7936 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 226 - i32.const 7968 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 227 - i32.const 8000 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 228 - i32.const 8032 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 229 - i32.const 8064 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 230 - i32.const 8096 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/INSTRUCTIONS - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MaybePageFault#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 11 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:isFault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:isAccess - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:fault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/arraybuffer/ArrayBufferView#constructor (param $this i32) (param $length i32) (param $alignLog2 i32) (result i32) - (local $buffer i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 3 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:buffer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:byteLength - local.get $length - i32.const 1073741820 - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8224 - i32.const 19 - i32.const 57 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $length - local.get $alignLog2 - i32.shl - local.tee $length - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $buffer - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $~lib/arraybuffer/ArrayBufferView#set:buffer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $buffer - call $~lib/arraybuffer/ArrayBufferView#set:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $length - call $~lib/arraybuffer/ArrayBufferView#set:byteLength - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $length - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#constructor - local.tee $this - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/memory-page/Page#constructor (param $this i32) (param $access i32) (param $raw i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 12 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $access - call $assembly/memory-page/Page#set:access - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $raw - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory-page/Page#set:raw - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory-page/RawPage#constructor (param $this i32) (param $id i32) (param $page i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 13 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $id - call $assembly/memory-page/RawPage#set:id - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $page - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory-page/RawPage#set:page - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $start:assembly/memory - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - call $start:assembly/memory-page - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - global.set $assembly/memory/NO_PAGE_FAULT - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - global.set $assembly/memory/EMPTY_UINT8ARRAY - i32.const 0 - global.get $assembly/memory-page/Access.None - i32.const 0 - i32.const -1 - i32.const 0 - call $assembly/memory-page/RawPage#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/memory-page/Page#constructor - global.set $assembly/memory/EMPTY_PAGE - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i64) - (local $value i64) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/OutcomeData#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.const 19 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/instructions/outcome/Outcome.Ok - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:staticJump - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:dJump - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/instructions/outcome/Result.PANIC - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:exitCode - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/bit~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.popcnt - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.popcnt - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.clz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.clz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ctz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.ctz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u8SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u16SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|8 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.const 65535 - i32.and - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|9 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/polyfills/bswap - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/instructions/outcome/staticJump (param $offset i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.StaticJump - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $offset - call $assembly/instructions/outcome/OutcomeData#set:staticJump - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/branch~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.eq - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.ne - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.lt_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.le_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.ge_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.gt_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.lt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.le_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.ge_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.gt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.eq - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ne - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_u - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ge_u - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ge_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/jump~anonymous|0 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:a - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/instructions/outcome/dJump (param $address i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.DynamicJump - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $address - call $assembly/instructions/outcome/OutcomeData#set:dJump - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/jump~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $address i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - local.get $address - call $assembly/instructions/outcome/dJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/jump~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/jump~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $address i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:d - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - local.get $address - call $assembly/instructions/outcome/dJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.const 32 - i64.shl - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/load~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory/Chunks#constructor (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 24 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:fault - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:first - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:second - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory/Chunks#constructor@varargs (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $first - i32.store - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $second - i32.store offset=4 - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - local.get $first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - local.get $second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - local.get $4 - call $assembly/memory/Chunks#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $"~lib/map/Map#find" (param $this i32) (param $key i32) (param $hashCode i32) (result i32) - (local $entry i32) - (local $taggedNext i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - i32.load - local.set $entry - loop $while-continue|0 - local.get $entry - if - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - local.set $taggedNext - local.get $taggedNext - i32.const 1 - i32.and - i32.eqz - if (result i32) - local.get $entry - call $"~lib/map/MapEntry#get:key" - local.get $key - i32.eq - else - i32.const 0 - end - if - local.get $entry - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $taggedNext - i32.const 1 - i32.const -1 - i32.xor - i32.and - local.set $entry - br $while-continue|0 - end - end - i32.const 0 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $"~lib/map/Map#has" (param $this i32) (param $key i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $key - local.get $key - call $~lib/util/hash/HASH - call $"~lib/map/Map#find" - i32.const 0 - i32.ne - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/PageData#constructor (param $this i32) (param $fault i32) (param $page i32) (param $relativeAddress i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 25 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/PageData#set:fault - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $page - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/PageData#set:page - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $relativeAddress - call $assembly/memory/PageData#set:relativeAddress - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory/fault (param $address i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isFault - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $address - call $assembly/memory/MaybePageFault#set:fault - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $"~lib/map/Map#get" (param $this i32) (param $key i32) (result i32) - (local $entry i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $key - local.get $key - call $~lib/util/hash/HASH - call $"~lib/map/Map#find" - local.set $entry - local.get $entry - i32.eqz - if - i32.const 9376 - i32.const 9440 - i32.const 105 - i32.const 17 - call $~lib/builtins/abort - unreachable - end - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory-page/Page#can (param $this i32) (param $access i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/Page#get:access - global.get $assembly/memory-page/Access.Write - i32.eq - if (result i32) - i32.const 1 - else - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/Page#get:access - local.get $access - i32.eq - end - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/Memory#getPage (param $this i32) (param $access i32) (param $address i32) (result i32) - (local $pageIdx i32) - (local $relAddress i32) - (local $pageStart i32) - (local $page i32) - (local $f i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $address - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $pageIdx - local.get $address - global.get $assembly/memory-page/PAGE_SIZE - i32.rem_u - local.set $relAddress - local.get $pageIdx - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - local.set $pageStart - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/memory/Memory#get:pages - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $pageIdx - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.get $pageStart - call $assembly/memory/fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory/EMPTY_PAGE - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/memory/Memory#get:pages - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $pageIdx - call $"~lib/map/Map#get" - local.tee $page - i32.store offset=8 - local.get $page - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $access - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $pageStart - call $assembly/memory/fault - local.tee $f - i32.store offset=12 - local.get $f - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isAccess - i32.const 0 - local.get $f - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory/EMPTY_PAGE - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $page - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/typedarray/Uint8Array#fill (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $value - local.get $start - local.get $end - call $~lib/util/bytes/FILL - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/typedarray/Uint8Array#fill@varargs (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $value - local.get $start - local.get $end - call $~lib/typedarray/Uint8Array#fill - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory-page/RawPage#get:data (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:page - i32.const 0 - i32.eq - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory-page/RawPage#set:page - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:page - local.tee $1 - i32.store offset=12 - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 9616 - i32.const 42 - i32.const 12 - call $~lib/builtins/abort - unreachable - end - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/Memory#getChunks (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) - (local $pageData i32) - (local $page i32) - (local $relativeAddress i32) - (local $endAddress i32) - (local $needSecondPage i32) - (local $first i32) - (local $secondPageIdx i32) - (local $secondPageStart i32) - (local $secondPage i32) - (local $f i32) - (local $firstChunk i32) - (local $secondChunk i32) - (local $16 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $bytes - i32.const 255 - i32.and - i32.const 0 - i32.eq - if - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $access - local.get $address - call $assembly/memory/Memory#getPage - local.tee $pageData - i32.store offset=4 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/PageData#get:fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/MaybePageFault#get:isFault - if - i32.const 0 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/PageData#get:fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/PageData#get:page - local.tee $page - i32.store offset=12 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/PageData#get:relativeAddress - local.set $relativeAddress - local.get $relativeAddress - local.get $bytes - i32.const 255 - i32.and - i32.add - local.set $endAddress - local.get $endAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.gt_u - local.set $needSecondPage - local.get $needSecondPage - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $page - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $relativeAddress - local.get $endAddress - call $~lib/typedarray/Uint8Array#subarray - local.tee $first - i32.store offset=20 - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $first - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - i32.const 2 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - local.get $address - local.get $bytes - i32.const 255 - i32.and - i32.add - i64.extend_i32_u - global.get $assembly/memory/MEMORY_SIZE - i64.rem_s - i32.wrap_i64 - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $secondPageIdx - local.get $secondPageIdx - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - local.set $secondPageStart - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/Memory#get:pages - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $secondPageIdx - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.get $secondPageStart - call $assembly/memory/fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/Memory#get:pages - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $secondPageIdx - call $"~lib/map/Map#get" - local.tee $secondPage - i32.store offset=24 - local.get $secondPage - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $access - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $secondPageStart - call $assembly/memory/fault - local.tee $f - i32.store offset=28 - local.get $f - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isAccess - i32.const 0 - local.get $f - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $page - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $relativeAddress - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $firstChunk - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $secondPage - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - local.get $relativeAddress - local.get $bytes - i32.const 255 - i32.and - i32.add - global.get $assembly/memory-page/PAGE_SIZE - i32.sub - call $~lib/typedarray/Uint8Array#subarray - local.tee $secondChunk - i32.store offset=36 - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $firstChunk - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - local.get $secondChunk - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory/Chunks#constructor - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - ) - (func $assembly/memory/ChunkBytes#constructor (param $this i32) (param $fault i32) (param $bytes i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 22 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $fault - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory/ChunkBytes#set:fault - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $bytes - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory/ChunkBytes#set:bytes - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/ChunkBytes#constructor@varargs (param $this i32) (param $fault i32) (param $bytes i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/staticarray/StaticArray#constructor - local.tee $bytes - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $fault - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $bytes - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/memory/ChunkBytes#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/getBytes (param $bytes i32) (param $first i32) (param $second i32) (result i32) - (local $res i32) - (local $len i32) - (local $i i32) - (local $i|6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $bytes - i32.const 255 - i32.and - call $~lib/staticarray/StaticArray#constructor - local.tee $res - i32.store - local.get $first - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $i - local.get $first - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|6 - loop $for-loop|1 - local.get $i|6 - local.get $second - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $len - local.get $i|6 - i32.add - local.get $second - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - local.get $i|6 - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $i|6 - i32.const 1 - i32.add - local.set $i|6 - br $for-loop|1 - end - end - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $assembly/memory/Memory#getBytes (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) - (local $res i32) - (local $data i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $access - local.get $address - local.get $bytes - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $assembly/memory/MaybePageFault#get:isFault - if - i32.const 0 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/ChunkBytes#constructor@varargs - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - global.get $~lib/memory/__stack_pointer - local.get $bytes - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:first - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:second - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/getBytes - local.tee $data - i32.store offset=16 - i32.const 0 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/ChunkBytes#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/memory/Result#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 21 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/memory/Result#set:ok - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/Result#set:fault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory/Memory#getU8 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/instructions/outcome/okOrFault (param $pageFault i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MaybePageFault#get:isAccess - if (result i32) - global.get $assembly/instructions/outcome/Result.FAULT_ACCESS - else - global.get $assembly/instructions/outcome/Result.FAULT - end - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MaybePageFault#get:fault - call $assembly/instructions/outcome/OutcomeData#set:exitCode - end - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/load~anonymous|2 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getI8 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/u8SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|3 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU16 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getI16 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $l i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/Result#set:fault - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.const 15 - i32.and - i32.shl - i32.or - local.set $l - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $l - call $assembly/instructions/utils/u16SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU32 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getI32 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $l i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/Result#set:fault - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i32.or - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i32.or - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i32.or - local.set $l - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $l - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU64 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 8 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 8 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 16 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 24 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 4 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 32 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 5 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 40 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 6 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 48 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 7 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 56 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU64 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU64 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/logic~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.xor - i64.const -1 - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $c i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $c - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $c - i64.add - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.mul - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.const 4294967296 - i64.or - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i32.add - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 2 - i64.const 32 - call $~lib/math/ipow64 - i64.add - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - i64.sub - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.mul - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i32.div_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i32.MIN_VALUE - i64.extend_i32_s - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i32.rem_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i32) - (local $a i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i32.const -1 - i32.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i32.MIN_VALUE - i32.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - i64.extend_i32_s - local.get $a - i64.extend_i32_s - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.div_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i64.MIN_VALUE - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|18 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.rem_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|19 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i64.MIN_VALUE - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|20 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperSigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|21 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperUnsigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|22 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperSignedUnsigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|23 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.lt_s - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|24 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.lt_u - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|25 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.gt_s - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|26 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.gt_u - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/mov~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_l - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_l_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/set~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.lt_u - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.lt_s - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.gt_u - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.gt_s - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_u - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/set~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_s - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/shift~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $imm i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $imm - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $imm - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $regValue i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $regValue - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regValue - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/typedarray/Uint8Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - i32.ge_u - if - i32.const 480 - i32.const 720 - i32.const 178 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $index - i32.add - local.get $value - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU8 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 1 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|0 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU16 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 2 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.gt_s - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $value - i32.const 65535 - i32.and - i32.const 8 - i32.const 15 - i32.and - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - else - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 65535 - i32.and - i32.const 8 - i32.const 15 - i32.and - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|1 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU32 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $v i32) - (local $len i32) - (local $i i32) - (local $i|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 4 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $value - local.set $v - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - local.get $v - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i32.const 8 - i32.shr_u - local.set $v - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i|7 - local.get $v - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i32.const 8 - i32.shr_u - local.set $v - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/instructions/store~anonymous|2 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#setU32 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU64 (param $this i32) (param $address i32) (param $value i64) (result i32) - (local $res i32) - (local $v i64) - (local $len i32) - (local $i i32) - (local $i|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 8 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $value - local.set $v - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - local.get $v - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i64.const 8 - i64.shr_u - local.set $v - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i|7 - local.get $v - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i64.const 8 - i64.shr_u - local.set $v - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/instructions/store~anonymous|3 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Memory#setU64 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/memory/Memory#setU32 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Memory#setU64 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/instructions/outcome/status (param $result i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $result - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Result.HOST - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $id - call $assembly/instructions/outcome/OutcomeData#set:exitCode - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:a - call $assembly/instructions/outcome/hostCall - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#pop (param $this i32) (result i32) - (local $len i32) - (local $val i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - local.set $len - local.get $len - i32.const 1 - i32.lt_s - if - i32.const 13120 - i32.const 8128 - i32.const 271 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $len - i32.const 1 - i32.sub - local.tee $len - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $val - i32.store offset=4 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $len - call $~lib/array/Array#set:length_ - local.get $val - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/console/console.log (param $message i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $message - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/bindings/dom/console.log - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory-page/Arena#acquire (param $this i32) (result i32) - (local $allocatedMemory i32) - (local $data i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:free - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - i32.const 0 - i32.gt_s - if - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:free - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#pop - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.set $allocatedMemory - local.get $allocatedMemory - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/Arena#get:arenaBytes - i32.eq - if - i32.const 13168 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/console/console.log - end - global.get $~lib/memory/__stack_pointer - local.get $allocatedMemory - global.get $assembly/memory-page/ALLOCATE_EAGERLY - i32.lt_u - if (result i32) - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - else - i32.const 0 - end - local.tee $data - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - i32.const 1 - i32.add - call $assembly/memory-page/Arena#set:extraPageIndex - i32.const 0 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/RawPage#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) - (local $newBucketsCapacity i32) - (local $newBuckets i32) - (local $newEntriesCapacity i32) - (local $newEntries i32) - (local $oldPtr i32) - (local $oldEnd i32) - (local $newPtr i32) - (local $oldEntry i32) - (local $newEntry i32) - (local $oldEntryKey i32) - (local $newBucketIndex i32) - (local $newBucketPtrBase i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $newBucketsMask - i32.const 1 - i32.add - local.set $newBucketsCapacity - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newBucketsCapacity - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newBuckets - i32.store - local.get $newBucketsCapacity - i32.const 8 - i32.mul - i32.const 3 - i32.div_s - local.set $newEntriesCapacity - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newEntriesCapacity - block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.0" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newEntries - i32.store offset=4 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entries" - local.set $oldPtr - local.get $oldPtr - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.1" - end - i32.mul - i32.add - local.set $oldEnd - local.get $newEntries - local.set $newPtr - loop $while-continue|0 - local.get $oldPtr - local.get $oldEnd - i32.ne - if - local.get $oldPtr - local.set $oldEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $newPtr - local.set $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:key" - local.set $oldEntryKey - local.get $newEntry - local.get $oldEntryKey - call $"~lib/map/MapEntry#set:key" - local.get $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:value" - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/MapEntry#set:value" - local.get $oldEntryKey - call $~lib/util/hash/HASH - local.get $newBucketsMask - i32.and - local.set $newBucketIndex - local.get $newBuckets - local.get $newBucketIndex - i32.const 4 - i32.mul - i32.add - local.set $newBucketPtrBase - local.get $newEntry - local.get $newBucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $newBucketPtrBase - local.get $newPtr - i32.store - local.get $newPtr - block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.2" - end - i32.add - local.set $newPtr - end - local.get $oldPtr - block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.3" - end - i32.add - local.set $oldPtr - br $while-continue|0 - end - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBuckets - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBucketsMask - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntries - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntriesCapacity - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#get:entriesCount" - call $"~lib/map/Map#set:entriesOffset" - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) - (local $hashCode i32) - (local $entry i32) - (local $entries i32) - (local $6 i32) - (local $bucketPtrBase i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $key - call $~lib/util/hash/HASH - local.set $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $key - local.get $hashCode - call $"~lib/map/Map#find" - local.set $entry - local.get $entry - if - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.eq - if - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.const 3 - i32.mul - i32.const 4 - i32.div_s - i32.lt_s - if (result i32) - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.const 1 - i32.shl - i32.const 1 - i32.or - end - call $"~lib/map/Map#rehash" - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.tee $entries - i32.store offset=8 - local.get $entries - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.tee $6 - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesOffset" - local.get $6 - block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.4" - end - i32.mul - i32.add - local.set $entry - local.get $entry - local.get $key - call $"~lib/map/MapEntry#set:key" - i32.const 0 - drop - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - local.set $bucketPtrBase - local.get $entry - local.get $bucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $bucketPtrBase - local.get $entry - i32.store - end - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) - (local $freeMemoryStart i32) - (local $newSbrk i64) - (local $pageIdx i32) - (local $i i32) - (local $page i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $freeMemoryStart - i32.store - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $amount - i32.const 0 - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - local.get $amount - i64.extend_i32_u - i64.add - local.set $newSbrk - local.get $newSbrk - global.get $assembly/memory/MEMORY_SIZE - i64.ge_s - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Result#get:fault - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isFault - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $newSbrk - i32.wrap_i64 - call $assembly/memory/Memory#set:sbrkAddress - local.get $newSbrk - i64.const 1 - i64.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i64.extend_i32_s - i64.shr_s - i32.wrap_i64 - local.set $pageIdx - local.get $pageIdx - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.const 1 - i32.add - local.set $i - loop $for-loop|0 - local.get $i - local.get $pageIdx - i32.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:arena - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=12 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory/Memory#get:pages - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $i - i32.const 0 - global.get $assembly/memory-page/Access.Write - local.get $page - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory-page/Page#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $"~lib/map/Map#set" - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $pageIdx - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#sbrk - local.tee $res - i32.store offset=12 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/codec~anonymous|0 (param $firstByte i32) (result i32) - (local $len i32) - (local $i i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $assembly/codec/MASKS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.const 255 - i32.and - i32.lt_u - if - local.get $firstByte - i32.const 255 - i32.and - global.get $assembly/codec/MASKS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $i - call $~lib/array/Array#__get - i32.ge_u - if - i32.const 8 - local.get $i - i32.sub - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/array/Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/array/Array#get:dataStart - local.set $sourceStart - i32.const 0 - i32.eqz - drop - local.get $targetStart - local.get $sourceStart - local.get $sourceLen - i32.const 0 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/liftBytes (param $data i32) (result i32) - (local $p i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $p - i32.store offset=4 - local.get $p - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#set<~lib/array/Array> - local.get $p - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#constructor (param $this i32) (param $source i32) (param $offset i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 38 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $source - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/codec/Decoder#set:source - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $offset - call $assembly/codec/Decoder#set:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/util/string/joinStringArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $4 i32) - (local $estLen i32) - (local $value i32) - (local $i i32) - (local $offset i32) - (local $sepLen i32) - (local $result i32) - (local $i|11 i32) - (local $valueLen i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 14400 - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - end - local.get $lastIndex - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - i32.load - local.tee $4 - i32.store - local.get $4 - if (result i32) - local.get $4 - else - i32.const 14400 - end - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - end - i32.const 0 - local.set $estLen - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $i - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $estLen - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - i32.add - local.set $estLen - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $offset - local.get $separator - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - local.set $sepLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - local.get $sepLen - local.get $lastIndex - i32.mul - i32.add - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=12 - i32.const 0 - local.set $i|11 - loop $for-loop|1 - local.get $i|11 - local.get $lastIndex - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $i|11 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - local.set $valueLen - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value - local.get $valueLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $valueLen - i32.add - local.set $offset - end - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i|11 - i32.const 1 - i32.add - local.set $i|11 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $lastIndex - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - memory.copy - end - local.get $result - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - i32.const 1 - i32.lt_s - drop - i32.const 1 - drop - local.get $this - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/staticarray/StaticArray<~lib/string/String>#get:length - local.get $separator - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/util/string/joinStringArray - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#ensureBytes (param $this i32) (param $need i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#get:offset - local.get $need - i32.add - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/codec/Decoder#get:source - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $need - i32.const 10 - call $~lib/number/U32#toString - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/codec/Decoder#get:source - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#get:offset - i32.sub - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=12 - i32.const 14560 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $2 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 14560 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 3 - local.get $3 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 14560 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 14400 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 16384 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/ValOffset#constructor (param $this i32) (param $value i32) (param $offset i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 40 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $value - call $assembly/codec/ValOffset#set:value - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $offset - call $assembly/codec/ValOffset#set:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/codec/decodeVarU32 (param $data i32) (result i32) - (local $length i32) - (local $first i32) - (local $3 i32) - (local $4 i32) - (local $msb i32) - (local $number i32) - (local $i i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - i32.const 1 - global.set $~argumentsLength - global.get $assembly/codec/variableLength - i32.load - call_indirect (type $0) - i32.const 255 - i32.and - local.set $length - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $first - local.get $length - i32.const 0 - i32.eq - if - i32.const 0 - local.get $first - i32.const 1 - call $assembly/codec/ValOffset#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.get $length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.const 10 - call $~lib/number/I32#toString - local.tee $4 - i32.store offset=8 - i32.const 16608 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $3 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 16608 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 3 - local.get $4 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 16608 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 14400 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 16384 - i32.const 108 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $first - i32.const 2 - i32.const 8 - local.get $length - i32.sub - call $~lib/math/ipow32 - i32.add - i32.const 2 - i32.const 8 - call $~lib/math/ipow32 - i32.sub - local.get $length - i32.const 8 - i32.mul - i32.shl - local.set $msb - i32.const 0 - local.set $number - local.get $length - i32.const 1 - i32.sub - local.set $i - loop $for-loop|0 - local.get $i - i32.const 0 - i32.ge_s - if - local.get $number - i32.const 8 - i32.shl - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $i - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.add - local.set $number - local.get $i - i32.const 1 - i32.sub - local.set $i - br $for-loop|0 - end - end - local.get $number - local.get $msb - i32.add - local.set $number - i32.const 0 - local.get $number - i32.const 1 - local.get $length - i32.add - call $assembly/codec/ValOffset#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/codec/Decoder#varU32 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/decodeVarU32 - local.tee $v - i32.store offset=12 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/ValOffset#get:offset - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/ValOffset#get:value - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#bytes (param $this i32) (param $len i32) (result i32) - (local $v i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $len - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:source - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $len - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $v - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $len - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/codec/Decoder#remainingBytes (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $v - i32.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/typedarray/Uint8Array#get:length - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/program/CodeAndMetadata#constructor (param $this i32) (param $code i32) (param $metadata i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 37 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $code - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/program/CodeAndMetadata#set:code - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $metadata - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/program/CodeAndMetadata#set:metadata - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/program/extractCodeAndMetadata (param $data i32) (result i32) - (local $decoder i32) - (local $metadataLength i32) - (local $metadata i32) - (local $code i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=4 - local.get $decoder - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/codec/Decoder#varU32 - local.set $metadataLength - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $metadataLength - call $assembly/codec/Decoder#bytes - local.tee $metadata - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/codec/Decoder#remainingBytes - local.tee $code - i32.store offset=12 - i32.const 0 - local.get $code - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $metadata - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/program/CodeAndMetadata#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/string/String#concat (param $this i32) (param $other i32) (result i32) - (local $thisSize i32) - (local $otherSize i32) - (local $outSize i32) - (local $out i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $thisSize - local.get $other - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $otherSize - local.get $thisSize - local.get $otherSize - i32.add - local.set $outSize - local.get $outSize - i32.const 0 - i32.eq - if - i32.const 14400 - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $out - local.get $this - local.get $thisSize - memory.copy - local.get $out - local.get $thisSize - i32.add - local.get $other - local.get $otherSize - memory.copy - local.get $out - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $~lib/string/String.__concat (param $left i32) (param $right i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $left - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $right - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/string/String#concat - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/string/String#padStart (param $this i32) (param $length i32) (param $pad i32) (result i32) - (local $thisSize i32) - (local $targetSize i32) - (local $padSize i32) - (local $prependSize i32) - (local $out i32) - (local $repeatCount i32) - (local $restBase i32) - (local $restSize i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $thisSize - local.get $length - i32.const 1 - i32.shl - local.set $targetSize - local.get $pad - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $padSize - local.get $targetSize - local.get $thisSize - i32.lt_u - if (result i32) - i32.const 1 - else - local.get $padSize - i32.eqz - end - if - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $targetSize - local.get $thisSize - i32.sub - local.set $prependSize - global.get $~lib/memory/__stack_pointer - local.get $targetSize - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $prependSize - local.get $padSize - i32.gt_u - if - local.get $prependSize - i32.const 2 - i32.sub - local.get $padSize - i32.div_u - local.set $repeatCount - local.get $repeatCount - local.get $padSize - i32.mul - local.set $restBase - local.get $prependSize - local.get $restBase - i32.sub - local.set $restSize - local.get $out - local.get $pad - local.get $padSize - local.get $repeatCount - call $~lib/memory/memory.repeat - local.get $out - local.get $restBase - i32.add - local.get $pad - local.get $restSize - memory.copy - else - local.get $out - local.get $pad - local.get $prependSize - memory.copy - end - local.get $out - local.get $prependSize - i32.add - local.get $this - local.get $thisSize - memory.copy - local.get $out - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $assembly/index/disassemble~anonymous|0 (param $acc i32) (param $x i32) (param $$2 i32) (param $$3 i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $acc - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $x - i32.const 16 - call $~lib/number/U8#toString - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - i32.const 2 - i32.const 14800 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $~lib/string/String#padStart - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/string/String.__concat - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#reduce<~lib/string/String> (param $this i32) (param $fn i32) (param $initialValue i32) (result i32) - (local $array i32) - (local $fn|4 i32) - (local $initialValue|5 i32) - (local $ptr i32) - (local $i i32) - (local $k i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - block $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $array - i32.store - global.get $~lib/memory/__stack_pointer - local.get $fn - local.tee $fn|4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $initialValue - local.tee $initialValue|5 - i32.store offset=8 - local.get $array - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.set $ptr - i32.const 0 - local.set $i - local.get $array - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.set $k - loop $for-loop|0 - local.get $i - local.get $k - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $initialValue|5 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - local.get $ptr - local.get $i - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.get $i - local.get $array - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 4 - global.set $~argumentsLength - local.get $fn|4 - i32.load - call_indirect (type $5) - local.tee $initialValue|5 - i32.store offset=8 - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $initialValue|5 - br $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" - end - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $assembly/codec/Decoder#u8 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/Mask#constructor (param $this i32) (param $packedMask i32) (param $codeLength i32) (result i32) - (local $lastInstructionOffset i32) - (local $i i32) - (local $bits i32) - (local $index i32) - (local $b i32) - (local $isSet i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 31 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - call $assembly/program/Mask#set:bytesToSkip - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - local.get $codeLength - call $~lib/staticarray/StaticArray#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/Mask#set:bytesToSkip - i32.const 0 - local.set $lastInstructionOffset - local.get $packedMask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.sub - local.set $i - loop $for-loop|0 - local.get $i - i32.const 0 - i32.ge_s - if - local.get $packedMask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $bits - local.get $i - i32.const 8 - i32.mul - local.set $index - i32.const 7 - local.set $b - loop $for-loop|2 - local.get $b - i32.const 0 - i32.ge_s - if - local.get $bits - i32.const 128 - i32.and - local.set $isSet - local.get $bits - i32.const 1 - i32.const 7 - i32.and - i32.shl - local.set $bits - local.get $index - local.get $b - i32.add - local.get $codeLength - i32.lt_s - if - local.get $isSet - if (result i32) - i32.const 0 - else - local.get $lastInstructionOffset - i32.const 1 - i32.add - end - local.set $lastInstructionOffset - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/Mask#get:bytesToSkip - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $index - local.get $b - i32.add - local.get $lastInstructionOffset - global.get $assembly/program/MAX_SKIP - i32.const 1 - i32.add - i32.lt_u - if (result i32) - local.get $lastInstructionOffset - else - global.get $assembly/program/MAX_SKIP - i32.const 1 - i32.add - end - call $~lib/staticarray/StaticArray#__set - end - local.get $b - i32.const 1 - i32.sub - local.set $b - br $for-loop|2 - end - end - local.get $i - i32.const 1 - i32.sub - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - ) - (func $assembly/program/JumpTable#constructor (param $this i32) (param $itemBytes i32) (param $data i32) (result i32) - (local $jumps i32) - (local $i i32) - (local $num i64) - (local $j i32) - (local $nextNum i64) - (local $isOverflow i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 33 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - call $assembly/program/JumpTable#set:jumps - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $itemBytes - i32.const 255 - i32.and - i32.const 0 - i32.gt_u - if (result i32) - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.get $itemBytes - i32.const 255 - i32.and - i32.div_s - else - i32.const 0 - end - call $~lib/staticarray/StaticArray#constructor - local.tee $jumps - i32.store offset=8 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - i64.const 0 - local.set $num - local.get $itemBytes - i32.const 1 - i32.sub - i32.const 255 - i32.and - local.set $j - loop $for-loop|1 - local.get $j - i32.const 0 - i32.ge_s - if - local.get $num - i64.const 8 - i64.shl - local.set $nextNum - local.get $nextNum - local.get $num - i64.lt_u - local.set $isOverflow - local.get $nextNum - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - local.get $j - i32.add - call $~lib/typedarray/Uint8Array#__get - i64.extend_i32_u - i64.add - local.set $nextNum - local.get $isOverflow - if (result i32) - i32.const 1 - else - local.get $nextNum - local.get $num - i64.lt_u - end - local.set $isOverflow - local.get $isOverflow - if (result i64) - global.get $~lib/builtins/u64.MAX_VALUE - else - local.get $nextNum - end - local.set $num - local.get $j - i32.const 1 - i32.sub - local.set $j - br $for-loop|1 - end - end - local.get $jumps - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - local.get $itemBytes - i32.const 255 - i32.and - i32.div_s - local.get $num - call $~lib/staticarray/StaticArray#__set - local.get $i - local.get $itemBytes - i32.const 255 - i32.and - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $jumps - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $assembly/program/JumpTable#set:jumps - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/Mask#isInstruction (param $this i32) (param $index i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - i64.extend_i32_u - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i64.extend_i32_s - i64.ge_u - if - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $index - call $~lib/staticarray/StaticArray#__get - i32.const 0 - i32.eq - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/program/Mask#skipBytesToNextInstruction (param $this i32) (param $i i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $i - i32.const 1 - i32.add - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i32.lt_u - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $i - i32.const 1 - i32.add - call $~lib/staticarray/StaticArray#__get - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/BasicBlocks#constructor (param $this i32) (param $code i32) (param $mask i32) (result i32) - (local $len i32) - (local $isStartOrEnd i32) - (local $n i32) - (local $isInstructionInMask i32) - (local $skipArgs i32) - (local $iData i32) - (local $isTerminating i32) - (local $newBlockStart i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 34 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - call $assembly/program/BasicBlocks#set:isStartOrEnd - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $len - call $~lib/staticarray/StaticArray#constructor - local.tee $isStartOrEnd - i32.store offset=8 - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set - i32.const 0 - local.set $n - loop $for-loop|0 - local.get $n - local.get $len - i32.lt_s - if - block $for-continue|0 - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $assembly/program/Mask#isInstruction - local.set $isInstructionInMask - local.get $isInstructionInMask - i32.eqz - if - br $for-continue|0 - end - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipArgs - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#__get - end - local.set $iData - local.get $iData - call $assembly/instructions/Instruction#get:isTerminating - local.set $isTerminating - local.get $isTerminating - if - local.get $n - i32.const 1 - i32.add - local.get $skipArgs - i32.add - local.set $newBlockStart - local.get $newBlockStart - local.get $len - i32.lt_s - if - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $newBlockStart - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set - end - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - local.get $n - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.END - i32.or - call $~lib/staticarray/StaticArray#__set - end - end - local.get $n - i32.const 1 - i32.add - local.set $n - br $for-loop|0 - end - end - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - call $assembly/program/BasicBlocks#set:isStartOrEnd - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - ) - (func $assembly/program/Program#constructor (param $this i32) (param $code i32) (param $mask i32) (param $jumpTable i32) (param $basicBlocks i32) (result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 30 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $code - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:code - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:mask - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:jumpTable - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:basicBlocks - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/program/deblob (param $program i32) (result i32) - (local $decoder i32) - (local $jumpTableLength i32) - (local $jumpTableItemLength i32) - (local $codeLength i32) - (local $jumpTableLengthInBytes i32) - (local $rawJumpTable i32) - (local $rawCode i32) - (local $rawMask i32) - (local $mask i32) - (local $jumpTable i32) - (local $basicBlocks i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $program - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=4 - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#varU32 - local.set $jumpTableLength - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#u8 - local.set $jumpTableItemLength - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#varU32 - local.set $codeLength - local.get $jumpTableLength - local.get $jumpTableItemLength - i32.mul - local.set $jumpTableLengthInBytes - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $jumpTableLengthInBytes - call $assembly/codec/Decoder#bytes - local.tee $rawJumpTable - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - call $assembly/codec/Decoder#bytes - local.tee $rawCode - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - i32.const 7 - i32.add - i32.const 8 - i32.div_u - call $assembly/codec/Decoder#bytes - local.tee $rawMask - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $rawMask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $jumpTableItemLength - local.get $rawJumpTable - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/program/JumpTable#constructor - local.tee $jumpTable - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $rawCode - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $mask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - call $assembly/program/BasicBlocks#constructor - local.tee $basicBlocks - i32.store offset=32 - i32.const 0 - local.get $rawCode - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $mask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - local.get $jumpTable - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=36 - local.get $12 - local.get $basicBlocks - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=40 - local.get $12 - call $assembly/program/Program#constructor - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/decodeArguments (param $kind i32) (param $data i32) (param $lim i32) (result i32) - (local $extended i32) - (local $i i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - global.get $assembly/arguments/REQUIRED_BYTES - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $kind - call $~lib/array/Array#__get - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/arguments/REQUIRED_BYTES - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $kind - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#constructor - local.tee $extended - i32.store offset=4 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $extended - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $extended - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $lim - i32.const 2 - global.set $~argumentsLength - global.get $assembly/arguments/DECODERS - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $kind - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $3) - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $lim - i32.const 2 - global.set $~argumentsLength - global.get $assembly/arguments/DECODERS - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $kind - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $3) - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/api-generic/getAssembly (param $p i32) (result i32) - (local $len i32) - (local $v i32) - (local $i i32) - (local $instruction i32) - (local $iData i32) - (local $6 i32) - (local $skipBytes i32) - (local $args i32) - (local $9 i32) - (local $argsArray i32) - (local $relevantArgs i32) - (local $i|12 i32) - (local $13 i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - local.get $len - i32.const 0 - i32.eq - if - i32.const 16928 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 14400 - local.tee $v - i32.store offset=8 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - call $assembly/program/Mask#isInstruction - i32.eqz - if - i32.const 17008 - i32.const 17120 - i32.const 46 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $instruction - call $~lib/array/Array#__get - end - local.set $iData - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const 17200 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - i32.const 10 - call $~lib/number/I32#toString - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 17232 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/string/String#concat - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $iData - call $assembly/instructions/Instruction#get:namePtr - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $~lib/memory/__stack_pointer - local.get $instruction - i32.const 10 - call $~lib/number/U8#toString - local.tee $6 - i32.store offset=20 - i32.const 17328 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 1 - local.get $6 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 17328 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 14400 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipBytes - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - local.get $i - i32.const 1 - i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $skipBytes - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - i32.const 42 - i32.const 0 - call $~lib/rt/__newArray - local.tee $9 - i32.store offset=28 - local.get $9 - i32.const 0 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:a - call $~lib/array/Array#__set - local.get $9 - i32.const 1 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:b - call $~lib/array/Array#__set - local.get $9 - i32.const 2 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:c - call $~lib/array/Array#__set - local.get $9 - i32.const 3 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:d - call $~lib/array/Array#__set - local.get $9 - local.tee $argsArray - i32.store offset=32 - global.get $assembly/arguments/RELEVANT_ARGS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $iData - call $assembly/instructions/Instruction#get:kind - call $~lib/array/Array#__get - local.set $relevantArgs - i32.const 0 - local.set $i|12 - loop $for-loop|1 - local.get $i|12 - local.get $relevantArgs - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $~lib/memory/__stack_pointer - local.get $argsArray - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - local.get $i|12 - call $~lib/array/Array#__get - i32.const 10 - call $~lib/number/U32#toString - local.tee $13 - i32.store offset=36 - i32.const 17424 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 1 - local.get $13 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 17424 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 14400 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - local.get $i|12 - i32.const 1 - i32.add - local.set $i|12 - br $for-loop|1 - end - end - local.get $i - local.get $skipBytes - i32.add - local.set $i - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - ) - (func $assembly/codec/Decoder#u24 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 3 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 3 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u16 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 2 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.const 15 - i32.and - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u32 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 4 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 3 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 4 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#isExhausted (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#get:offset - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $assembly/codec/Decoder#get:source - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - i32.ge_s - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $assembly/codec/Decoder#finish (param $this i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - i32.const 17456 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - call $assembly/codec/Decoder#get:source - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/codec/Decoder#get:offset - i32.sub - i32.const 10 - call $~lib/number/I32#toString - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/string/String#concat - i32.const 16384 - i32.const 31 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/decodeSpi (param $data i32) (result i32) - (local $decoder i32) - (local $roLength i32) - (local $rwLength i32) - (local $_heapPages i32) - (local $_stackSize i32) - (local $_roMem i32) - (local $_rwMem i32) - (local $codeLength i32) - (local $code i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=4 - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/codec/Decoder#u24 - local.set $roLength - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/codec/Decoder#u24 - local.set $rwLength - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/codec/Decoder#u16 - local.set $_heapPages - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/codec/Decoder#u24 - local.set $_stackSize - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $roLength - call $assembly/codec/Decoder#bytes - local.tee $_roMem - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $rwLength - call $assembly/codec/Decoder#bytes - local.tee $_rwMem - i32.store offset=12 - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/codec/Decoder#u32 - local.set $codeLength - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $codeLength - call $assembly/codec/Decoder#bytes - local.tee $code - i32.store offset=16 - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/codec/Decoder#finish - local.get $code - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/program/deblob - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $assembly/index/disassemble (param $input i32) (param $kind i32) (param $withMetadata i32) (result i32) - (local $program i32) - (local $output i32) - (local $data i32) - (local $p i32) - (local $p|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $input - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/program/liftBytes - local.tee $program - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 14400 - local.tee $output - i32.store offset=8 - local.get $withMetadata - global.get $assembly/index/HasMetadata.Yes - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $program - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/program/extractCodeAndMetadata - local.tee $data - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/program/CodeAndMetadata#get:code - local.tee $program - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 16656 - local.tee $output - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $output - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 16704 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String.__concat - local.tee $output - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $output - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=32 - local.get $8 - call $assembly/program/CodeAndMetadata#get:metadata - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=20 - local.get $8 - i32.const 16736 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 14400 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/typedarray/Uint8Array#reduce<~lib/string/String> - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String.__concat - local.tee $output - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $output - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 16768 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String.__concat - local.tee $output - i32.store offset=8 - end - local.get $kind - global.get $assembly/index/InputKind.Generic - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $program - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/program/deblob - local.tee $p - i32.store offset=36 - local.get $output - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $p - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=20 - local.get $8 - call $assembly/api-generic/getAssembly - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String.__concat - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $kind - global.get $assembly/index/InputKind.SPI - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $program - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/program/decodeSpi - local.tee $p|7 - i32.store offset=40 - local.get $output - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $p|7 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=20 - local.get $8 - call $assembly/api-generic/getAssembly - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String.__concat - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - i32.const 17584 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $bufferSize i32) - (local $buffer i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 43 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:length_ - local.get $length - i32.const 1073741820 - i32.const 3 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8128 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - local.tee $2 - i32.const 8 - local.tee $3 - local.get $2 - local.get $3 - i32.gt_u - select - i32.const 3 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $bufferSize - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $length - call $~lib/array/Array#set:length_ - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $~lib/array/Array#fill (param $this i32) (param $value i64) (param $start i32) (param $end i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.get $value - local.get $start - local.get $end - call $~lib/util/bytes/FILL - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/array/Array#fill@varargs (param $this i32) (param $value i64) (param $start i32) (param $end i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $value - local.get $start - local.get $end - call $~lib/array/Array#fill - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/api-generic/VmInput#constructor (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 47 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/array/Array#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i64.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/array/Array#fill@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/api-generic/VmInput#set:registers - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/api-generic/VmInput#set:pc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i64.const 0 - call $assembly/api-generic/VmInput#set:gas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 17632 - call $~lib/rt/__newArray - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/api-generic/VmInput#set:program - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 17664 - call $~lib/rt/__newArray - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/api-generic/VmInput#set:pageMap - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 17696 - call $~lib/rt/__newArray - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/api-generic/VmInput#set:memory - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i64) - (local $value i64) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $"~lib/map/Map#constructor" (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.const 18 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 4 - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - i32.const 1 - i32.sub - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 4 - block $"~lib/map/ENTRY_SIZE|inlined.5" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.5" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesOffset" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/typedarray/Uint8Array.wrap (param $buffer i32) (param $byteOffset i32) (param $length i32) (result i32) - (local $buffer|3 i32) - (local $byteOffset|4 i32) - (local $len i32) - (local $byteLength i32) - (local $bufferByteLength i32) - (local $out i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - block $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $buffer - local.tee $buffer|3 - i32.store - local.get $byteOffset - local.set $byteOffset|4 - local.get $length - local.set $len - local.get $buffer|3 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/arraybuffer/ArrayBuffer#get:byteLength - local.set $bufferByteLength - local.get $byteOffset|4 - local.get $bufferByteLength - i32.gt_u - local.get $byteOffset|4 - i32.const 0 - i32.and - i32.or - if - i32.const 480 - i32.const 720 - i32.const 1860 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $len - i32.const 0 - i32.lt_s - if - local.get $len - i32.const -1 - i32.eq - if - local.get $bufferByteLength - i32.const 0 - i32.and - if - i32.const 8176 - i32.const 720 - i32.const 1865 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - local.get $bufferByteLength - local.get $byteOffset|4 - i32.sub - local.set $byteLength - else - i32.const 8176 - i32.const 720 - i32.const 1869 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - else - local.get $len - i32.const 0 - i32.shl - local.set $byteLength - local.get $byteOffset|4 - local.get $byteLength - i32.add - local.get $bufferByteLength - i32.gt_s - if - i32.const 8176 - i32.const 720 - i32.const 1874 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=8 - local.get $out - local.get $buffer|3 - i32.store - local.get $out - local.get $buffer|3 - i32.const 0 - call $~lib/rt/itcms/__link - local.get $out - local.get $byteLength - i32.store offset=8 - local.get $out - local.get $buffer|3 - local.get $byteOffset|4 - i32.add - i32.store offset=4 - local.get $out - br $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" - end - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $~lib/array/Array#unshift (param $this i32) (param $value i32) (result i32) - (local $len i32) - (local $ptr i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.set $ptr - local.get $ptr - i32.const 4 - i32.add - local.get $ptr - local.get $len - i32.const 1 - i32.sub - i32.const 2 - i32.shl - memory.copy - local.get $ptr - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory-page/Arena#constructor (param $this i32) (param $pageCount i32) (result i32) - (local $2 i32) - (local $data i32) - (local $i i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 16 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:free - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:arenaBytes - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:extraPageIndex - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/memory-page/PAGE_SIZE - local.get $pageCount - i32.mul - call $assembly/memory-page/Arena#set:arenaBytes - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - i32.const 2 - i32.const 17 - i32.const 17728 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory-page/Arena#set:free - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pageCount - call $assembly/memory-page/Arena#set:extraPageIndex - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory-page/Arena#get:arenaBytes - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $data - i32.store offset=12 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pageCount - i32.lt_s - if - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory-page/Arena#get:free - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - local.get $i - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array.wrap - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory-page/RawPage#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/array/Array#unshift - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/memory/MemoryBuilder#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 50 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#constructor" - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/MemoryBuilder#set:pages - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 128 - call $assembly/memory-page/Arena#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/MemoryBuilder#set:arena - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.set $sourceStart - i32.const 0 - i32.eqz - drop - local.get $targetStart - local.get $sourceStart - local.get $sourceLen - i32.const 0 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MemoryBuilder#setData (param $this i32) (param $access i32) (param $address i32) (param $data i32) (result i32) - (local $currentAddress i32) - (local $currentData i32) - (local $pageIdx i32) - (local $page i32) - (local $relAddress i32) - (local $page|9 i32) - (local $spaceInPage i32) - (local $end i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - local.get $address - local.set $currentAddress - global.get $~lib/memory/__stack_pointer - local.get $data - local.tee $currentData - i32.store - loop $while-continue|0 - local.get $currentData - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - i32.gt_s - if - local.get $currentAddress - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $pageIdx - local.get $pageIdx - global.get $assembly/memory-page/RESERVED_PAGES - i32.lt_u - if - i32.const 17760 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $pageIdx - i32.const 10 - call $~lib/number/U32#toString - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/string/String#concat - i32.const 17856 - i32.const 67 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $assembly/memory/MemoryBuilder#get:pages - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $pageIdx - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $assembly/memory/MemoryBuilder#get:arena - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=12 - local.get $this - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=16 - local.get $12 - call $assembly/memory/MemoryBuilder#get:pages - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $pageIdx - i32.const 0 - local.get $access - local.get $page - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=16 - local.get $12 - call $assembly/memory-page/Page#constructor - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $"~lib/map/Map#set" - drop - end - local.get $currentAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.rem_u - local.set $relAddress - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $assembly/memory/MemoryBuilder#get:pages - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $pageIdx - call $"~lib/map/Map#get" - local.tee $page|9 - i32.store offset=20 - global.get $assembly/memory-page/PAGE_SIZE - local.get $relAddress - i32.sub - local.set $spaceInPage - local.get $currentData - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - local.get $spaceInPage - i32.lt_u - if (result i32) - local.get $currentData - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - else - local.get $spaceInPage - end - local.set $end - local.get $page|9 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=24 - local.get $12 - call $assembly/memory-page/Page#get:raw - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=16 - local.get $12 - call $assembly/memory-page/RawPage#get:data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $currentData - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=16 - local.get $12 - i32.const 0 - local.get $end - call $~lib/typedarray/Uint8Array#subarray - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - local.get $relAddress - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $currentAddress - local.get $end - i32.add - local.set $currentAddress - global.get $~lib/memory/__stack_pointer - local.get $currentData - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $end - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $currentData - i32.store - br $while-continue|0 - end - end - local.get $this - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory/Memory#constructor (param $this i32) (param $arena i32) (param $pages i32) (param $sbrkAddress i32) (result i32) - (local $sbrkPage i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 15 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $arena - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory/Memory#set:arena - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory/Memory#set:pages - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $sbrkAddress - call $assembly/memory/Memory#set:sbrkAddress - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $sbrkAddress - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $sbrkPage - local.get $sbrkPage - global.get $assembly/memory-page/RESERVED_PAGES - i32.lt_u - if - i32.const 17920 - i32.const 17856 - i32.const 104 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $sbrkPage - call $"~lib/map/Map#has" - if (result i32) - local.get $sbrkPage - else - local.get $sbrkPage - i32.const 1 - i32.sub - end - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/memory/MemoryBuilder#build (param $this i32) (param $sbrkAddress i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - i32.const 0 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MemoryBuilder#get:arena - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MemoryBuilder#get:pages - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $sbrkAddress - call $assembly/memory/Memory#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api-generic/buildMemory (param $builder i32) (param $pages i32) (param $chunks i32) (result i32) - (local $sbrkIndex i32) - (local $i i32) - (local $initPage i32) - (local $i|6 i32) - (local $initChunk i32) - (local $data i32) - (local $i|9 i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $assembly/memory-page/RESERVED_MEMORY - local.set $sbrkIndex - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pages - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/array/Array#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $pages - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $i - call $~lib/array/Array#__get - local.tee $initPage - i32.store offset=4 - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-generic/InitialPage#get:access - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-generic/InitialPage#get:address - i32.const 0 - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-generic/InitialPage#get:length - call $~lib/typedarray/Uint8Array#constructor - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/MemoryBuilder#setData - drop - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/api-generic/InitialPage#get:access - global.get $assembly/memory-page/Access.Write - i32.eq - if - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/api-generic/InitialPage#get:address - local.get $sbrkIndex - i32.lt_u - if (result i32) - local.get $sbrkIndex - else - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/api-generic/InitialPage#get:address - end - local.set $sbrkIndex - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|6 - loop $for-loop|1 - local.get $i|6 - local.get $chunks - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/array/Array#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $chunks - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $i|6 - call $~lib/array/Array#__get - local.tee $initChunk - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $initChunk - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/api-generic/InitialChunk#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $data - i32.store offset=20 - i32.const 0 - local.set $i|9 - loop $for-loop|2 - local.get $i|9 - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $i|9 - local.get $initChunk - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-generic/InitialChunk#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - local.get $i|9 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $i|9 - i32.const 1 - i32.add - local.set $i|9 - br $for-loop|2 - end - end - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - global.get $assembly/memory-page/Access.None - local.get $initChunk - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-generic/InitialChunk#get:address - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/MemoryBuilder#setData - drop - local.get $i|6 - i32.const 1 - i32.add - local.set $i|6 - br $for-loop|1 - end - end - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $sbrkIndex - call $assembly/memory/MemoryBuilder#build - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $assembly/gas/GasCounterU64#constructor (param $this i32) (param $gas i64) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 51 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $gas - call $assembly/gas/GasCounterU64#set:gas - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/interpreter/Interpreter#constructor (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 33 - i32.const 29 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:program - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:registers - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:memory - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:gas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:pc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:exitCode - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:nextPc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:useSbrkGas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/interpreter/Interpreter#set:program - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/interpreter/Interpreter#set:registers - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/interpreter/Interpreter#set:memory - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i64.const 0 - call $assembly/gas/gasCounter - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/interpreter/Interpreter#set:gas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:pc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - global.get $assembly/interpreter/Status.OK - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:exitCode - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:nextPc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:useSbrkGas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/string/String#substring (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $len i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $finalStart i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $finalEnd i32) - (local $14 i32) - (local $15 i32) - (local $fromPos i32) - (local $17 i32) - (local $18 i32) - (local $toPos i32) - (local $size i32) - (local $out i32) - (local $22 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $~lib/string/String#get:length - local.set $len - local.get $start - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - local.tee $6 - local.get $len - local.tee $7 - local.get $6 - local.get $7 - i32.lt_s - select - local.set $finalStart - local.get $end - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_s - select - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - local.set $finalEnd - local.get $finalStart - local.tee $14 - local.get $finalEnd - local.tee $15 - local.get $14 - local.get $15 - i32.lt_s - select - i32.const 1 - i32.shl - local.set $fromPos - local.get $finalStart - local.tee $17 - local.get $finalEnd - local.tee $18 - local.get $17 - local.get $18 - i32.gt_s - select - i32.const 1 - i32.shl - local.set $toPos - local.get $toPos - local.get $fromPos - i32.sub - local.set $size - local.get $size - i32.eqz - if - i32.const 14400 - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - end - local.get $fromPos - i32.eqz - if (result i32) - local.get $toPos - local.get $len - i32.const 1 - i32.shl - i32.eq - else - i32.const 0 - end - if - local.get $this - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - end - global.get $~lib/memory/__stack_pointer - local.get $size - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $out - local.get $this - local.get $fromPos - i32.add - local.get $size - memory.copy - local.get $out - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - ) - (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $value i64) - (local $sepLen i32) - (local $estLen i32) - (local $result i32) - (local $offset i32) - (local $value|9 i64) - (local $i i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 14400 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $lastIndex - i32.eqz - if - local.get $dataStart - i64.load - local.set $value - i32.const 0 - drop - i32.const 8 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 10 - call $~lib/util/number/utoa64 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $separator - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - local.set $sepLen - i32.const 20 - local.get $sepLen - i32.add - local.get $lastIndex - i32.mul - i32.const 20 - i32.add - local.set $estLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=4 - i32.const 0 - local.set $offset - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $lastIndex - i32.lt_s - if - local.get $dataStart - local.get $i - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $dataStart - local.get $lastIndex - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $estLen - local.get $offset - i32.gt_s - if - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.const 0 - local.get $offset - call $~lib/string/String#substring - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/staticarray/StaticArray#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 0 - drop - i32.const 1 - drop - local.get $this - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/staticarray/StaticArray#get:length - local.get $separator - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/util/string/joinIntegerArray - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api-generic/runVm~anonymous|0 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 16704 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $x - i32.const 16 - call $~lib/number/U64#toString - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/string/String#concat - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $this i32) (param $fn i32) (result i32) - (local $len i32) - (local $out i32) - (local $outStart i32) - (local $i i32) - (local $result i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/staticarray/StaticArray#get:length - local.set $len - global.get $~lib/memory/__stack_pointer - local.get $len - i32.const 2 - i32.const 52 - i32.const 0 - call $~lib/rt/__newArray - local.tee $out - i32.store offset=4 - local.get $out - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.set $outStart - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.get $i - i32.const 3 - i32.shl - i32.add - i64.load - local.get $i - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - i32.const 3 - global.set $~argumentsLength - local.get $fn - i32.load - call_indirect (type $17) - local.tee $result - i32.store offset=8 - local.get $outStart - local.get $i - i32.const 2 - i32.shl - i32.add - local.get $result - i32.store - i32.const 1 - drop - local.get $out - local.get $result - i32.const 1 - call $~lib/rt/itcms/__link - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $out - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $~lib/array/Array<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) - (local $ptr i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.set $ptr - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array<~lib/string/String>#get:length_ - local.set $len - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - i32.const 1 - i32.lt_s - drop - i32.const 1 - drop - local.get $ptr - local.get $len - local.get $separator - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/util/string/joinStringArray - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api-generic/runVm~anonymous|1 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 16704 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $x - i32.const 16 - call $~lib/number/U64#toString - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/string/String#concat - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/program/ResolvedArguments#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.const 54 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:a - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:b - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:c - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:d - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/program/ResolvedArguments#set:decoded - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/program/resolveArguments (param $kind i32) (param $data i32) (param $lim i32) (param $registers i32) (result i32) - (local $args i32) - (local $resolved i32) - (local $6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $kind - local.get $data - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $lim - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=4 - local.get $args - i32.const 0 - i32.eq - if - i32.const 0 - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/program/ResolvedArguments#constructor - local.tee $resolved - i32.store offset=8 - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/program/ResolvedArguments#set:decoded - block $case13|0 - block $case12|0 - block $case11|0 - block $case10|0 - block $case9|0 - block $case8|0 - block $case7|0 - block $case6|0 - block $case5|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $kind - local.set $6 - local.get $6 - global.get $assembly/arguments/Arguments.Zero - i32.eq - br_if $case0|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneImm - i32.eq - br_if $case1|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoImm - i32.eq - br_if $case2|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneOff - i32.eq - br_if $case3|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegOneImm - i32.eq - br_if $case4|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegOneExtImm - i32.eq - br_if $case5|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i32.eq - br_if $case6|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i32.eq - br_if $case7|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoReg - i32.eq - br_if $case8|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i32.eq - br_if $case9|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i32.eq - br_if $case10|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoRegTwoImm - i32.eq - br_if $case11|0 - local.get $6 - global.get $assembly/arguments/Arguments.ThreeReg - i32.eq - br_if $case12|0 - br $case13|0 - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - i64.const 32 - i64.shl - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - i64.add - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:d - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:d - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - i32.const 18528 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $~lib/string/String#concat - i32.const 18608 - i32.const 347 - i32.const 7 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/interpreter/DjumpResult#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 55 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/interpreter/DjumpStatus.OK - call $assembly/interpreter/DjumpResult#set:status - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/interpreter/DjumpResult#set:newPc - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/interpreter/dJump (param $jumpTable i32) (param $address i32) (result i32) - (local $r i32) - (local $index i32) - (local $newPc i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/interpreter/DjumpResult#constructor - local.tee $r - i32.store - local.get $address - global.get $assembly/interpreter/EXIT - i32.eq - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.HALT - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $address - i32.const 0 - i32.eq - if (result i32) - i32.const 1 - else - local.get $address - global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR - i32.rem_u - i32.const 0 - i32.ne - end - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.PANIC - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $address - global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR - i32.div_u - i32.const 1 - i32.sub - local.set $index - local.get $index - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/JumpTable#get:jumps - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.PANIC - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/JumpTable#get:jumps - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $index - call $~lib/staticarray/StaticArray#__get - local.set $newPc - local.get $newPc - global.get $assembly/interpreter/MAX_U32 - i64.ge_u - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.PANIC - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $newPc - i32.wrap_i64 - call $assembly/interpreter/DjumpResult#set:newPc - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/interpreter/BranchResult#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 56 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/interpreter/BranchResult#set:isOkay - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/interpreter/BranchResult#set:newPc - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/program/BasicBlocks#isStart (param $this i32) (param $newPc i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $newPc - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i32.lt_u - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $newPc - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.START - i32.and - i32.const 0 - i32.gt_s - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/interpreter/branch (param $basicBlocks i32) (param $pc i32) (param $offset i32) (result i32) - (local $r i32) - (local $newPc i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/interpreter/BranchResult#constructor - local.tee $r - i32.store - local.get $pc - local.get $offset - i32.add - local.set $newPc - local.get $basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $newPc - call $assembly/program/BasicBlocks#isStart - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - call $assembly/interpreter/BranchResult#set:isOkay - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $newPc - call $assembly/interpreter/BranchResult#set:newPc - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/interpreter/Interpreter#nextStep (param $this i32) (result i32) - (local $pc i32) - (local $instruction i32) - (local $iData i32) - (local $skipBytes i32) - (local $args i32) - (local $alloc i64) - (local $gas i64) - (local $exe i32) - (local $outcome i32) - (local $10 i32) - (local $res i32) - (local $branchResult i32) - (local $branchResult|13 i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:status - global.get $assembly/interpreter/Status.HOST - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OK - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:nextPc - call $assembly/interpreter/Interpreter#set:pc - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const -1 - call $assembly/interpreter/Interpreter#set:nextPc - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:status - global.get $assembly/interpreter/Status.OK - i32.ne - if - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:nextPc - i32.const -1 - i32.ne - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:nextPc - call $assembly/interpreter/Interpreter#set:pc - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const -1 - call $assembly/interpreter/Interpreter#set:nextPc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const 0 - call $assembly/interpreter/Interpreter#set:exitCode - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:pc - local.set $pc - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - call $assembly/program/Mask#isInstruction - i32.eqz - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $assembly/instructions/Instruction#get:gas - call $assembly/gas/GasCounter#sub@override - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OOG - call $assembly/interpreter/Interpreter#set:status - else - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - end - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - call $~lib/typedarray/Uint8Array#__get - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/array/Array#get:length - i32.lt_s - if (result i32) - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $instruction - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION - end - local.set $iData - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $iData - call $assembly/instructions/Instruction#get:gas - call $assembly/gas/GasCounter#sub@override - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OOG - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $iData - global.get $assembly/instructions/MISSING_INSTRUCTION - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipBytes - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - local.get $pc - i32.const 1 - i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $skipBytes - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=16 - local.get $iData - global.get $assembly/instructions/SBRK - i32.eq - if (result i32) - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:useSbrkGas - else - i32.const 0 - end - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:registers - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - local.set $alloc - local.get $alloc - global.get $assembly/memory-page/PAGE_SIZE - i64.extend_i32_u - i64.add - i64.const 1 - i64.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i64.extend_i32_s - i64.shr_u - i64.const 16 - i64.mul - local.set $gas - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $gas - call $assembly/gas/GasCounter#sub@override - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OOG - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions-exe/RUN - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $instruction - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get - local.tee $exe - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/interpreter/Interpreter#get:registers - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/interpreter/Interpreter#get:memory - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - i32.const 3 - global.set $~argumentsLength - local.get $exe - i32.load - call_indirect (type $2) - local.tee $outcome - i32.store offset=24 - block $break|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:outcome - local.set $10 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.DynamicJump - i32.eq - br_if $case0|0 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.StaticJump - i32.eq - br_if $case1|0 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.Result - i32.eq - br_if $case2|0 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.Ok - i32.eq - br_if $case3|0 - br $break|0 - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:jumpTable - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:dJump - call $assembly/interpreter/dJump - local.tee $res - i32.store offset=28 - local.get $res - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/DjumpResult#get:status - global.get $assembly/interpreter/DjumpStatus.HALT - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.HALT - call $assembly/interpreter/Interpreter#set:status - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $res - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/DjumpResult#get:status - global.get $assembly/interpreter/DjumpStatus.PANIC - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:basicBlocks - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $res - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/DjumpResult#get:newPc - i32.const 0 - call $assembly/interpreter/branch - local.tee $branchResult - i32.store offset=32 - local.get $branchResult - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/BranchResult#get:isOkay - i32.eqz - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $branchResult - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/BranchResult#get:newPc - call $assembly/interpreter/Interpreter#set:pc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:basicBlocks - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:staticJump - call $assembly/interpreter/branch - local.tee $branchResult|13 - i32.store offset=36 - local.get $branchResult|13 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/BranchResult#get:isOkay - i32.eqz - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $branchResult|13 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/BranchResult#get:newPc - call $assembly/interpreter/Interpreter#set:pc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.HOST - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.HOST - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - call $assembly/interpreter/Interpreter#set:exitCode - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:pc - i32.const 1 - i32.add - local.get $skipBytes - i32.add - call $assembly/interpreter/Interpreter#set:nextPc - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.FAULT - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i64.const 1 - call $assembly/gas/GasCounter#sub@override - drop - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - global.get $assembly/memory-page/RESERVED_MEMORY - i32.lt_u - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - else - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.FAULT - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - call $assembly/interpreter/Interpreter#set:exitCode - end - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.FAULT_ACCESS - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i64.const 1 - call $assembly/gas/GasCounter#sub@override - drop - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.PANIC - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - call $assembly/interpreter/Interpreter#set:exitCode - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - i32.const 18944 - i32.const 18992 - i32.const 173 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:pc - i32.const 1 - local.get $skipBytes - i32.add - i32.add - call $assembly/interpreter/Interpreter#set:pc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - ) - (func $assembly/api-generic/VmOutput#constructor (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 44 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - global.get $assembly/interpreter/Status.OK - call $assembly/api-generic/VmOutput#set:status - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.const 3 - i32.const 43 - i32.const 19072 - call $~lib/rt/__newArray - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/api-generic/VmOutput#set:registers - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - call $assembly/api-generic/VmOutput#set:pc - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 19104 - call $~lib/rt/__newArray - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/api-generic/VmOutput#set:memory - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i64.const 0 - call $assembly/api-generic/VmOutput#set:gas - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - call $assembly/api-generic/VmOutput#set:exitCode - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#slice<~lib/array/Array> (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $length i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $sourceStart i32) - (local $size i32) - (local $out i32) - (local $outStart i32) - (local $18 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $18 - global.get $~lib/memory/__stack_pointer - local.get $18 - i32.store - local.get $18 - call $~lib/staticarray/StaticArray#get:length - local.set $length - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $start - local.get $length - i32.add - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - else - local.get $start - local.tee $6 - local.get $length - local.tee $7 - local.get $6 - local.get $7 - i32.lt_s - select - end - local.set $start - local.get $end - i32.const 0 - i32.lt_s - if (result i32) - local.get $end - local.get $length - i32.add - local.tee $8 - i32.const 0 - local.tee $9 - local.get $8 - local.get $9 - i32.gt_s - select - else - local.get $end - local.tee $10 - local.get $length - local.tee $11 - local.get $10 - local.get $11 - i32.lt_s - select - end - local.set $end - local.get $end - local.get $start - i32.sub - local.tee $12 - i32.const 0 - local.tee $13 - local.get $12 - local.get $13 - i32.gt_s - select - local.set $length - local.get $this - local.get $start - i32.const 3 - i32.shl - i32.add - local.set $sourceStart - local.get $length - i32.const 3 - i32.shl - local.set $size - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $out - i32.store offset=4 - i32.const 1 - drop - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 3 - i32.const 43 - i32.const 0 - call $~lib/rt/__newArray - local.tee $out - i32.store offset=4 - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - local.get $18 - i32.store - local.get $18 - call $~lib/array/Array#get:dataStart - local.set $outStart - i32.const 0 - drop - local.get $outStart - local.get $sourceStart - local.get $size - memory.copy - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - ) - (func $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $start - local.get $end - call $~lib/staticarray/StaticArray#slice<~lib/array/Array> - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $bufferSize i32) - (local $buffer i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 42 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:length_ - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8128 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - local.tee $2 - i32.const 8 - local.tee $3 - local.get $2 - local.get $3 - i32.gt_u - select - i32.const 2 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $bufferSize - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $length - call $~lib/array/Array#set:length_ - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.get $newLength - i32.const 2 - i32.const 0 - call $~lib/array/ensureCapacity - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $newLength - call $~lib/array/Array#set:length_ - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#keys" (param $this i32) (result i32) - (local $start i32) - (local $size i32) - (local $keys i32) - (local $length i32) - (local $i i32) - (local $entry i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.set $start - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.set $size - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $size - call $~lib/array/Array#constructor - local.tee $keys - i32.store offset=4 - i32.const 0 - local.set $length - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $size - i32.lt_s - if - local.get $start - local.get $i - block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.6" - end - i32.mul - i32.add - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $keys - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - local.tee $7 - i32.const 1 - i32.add - local.set $length - local.get $7 - local.get $entry - call $"~lib/map/MapEntry#get:key" - call $~lib/array/Array#__set - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $keys - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - call $~lib/array/Array#set:length - local.get $keys - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 0 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api-generic/InitialChunk#constructor (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 45 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - call $assembly/api-generic/InitialChunk#set:address - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 19168 - call $~lib/rt/__newArray - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/api-generic/InitialChunk#set:data - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - i32.const 0 - drop - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api-generic/getOutputChunks (param $memory i32) (result i32) - (local $1 i32) - (local $chunks i32) - (local $pages i32) - (local $currentChunk i32) - (local $i i32) - (local $pageIdx i32) - (local $page i32) - (local $n i32) - (local $v i32) - (local $10 i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 19136 - call $~lib/rt/__newArray - local.tee $chunks - i32.store - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory/Memory#get:pages - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $"~lib/map/Map#keys" - local.tee $pages - i32.store offset=12 - i32.const 0 - local.set $currentChunk - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pages - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/array/Array#get:length - i32.lt_s - if - block $for-continue|0 - local.get $pages - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $i - call $~lib/array/Array#__get - local.set $pageIdx - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory/Memory#get:pages - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $pageIdx - call $"~lib/map/Map#get" - local.tee $page - i32.store offset=16 - local.get $page - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory-page/Page#get:raw - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $assembly/memory-page/RawPage#get:page - i32.const 0 - i32.eq - if - br $for-continue|0 - end - i32.const 0 - local.set $n - loop $for-loop|1 - local.get $n - local.get $page - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=20 - local.get $11 - call $assembly/memory-page/Page#get:raw - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory-page/RawPage#get:data - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $page - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=20 - local.get $11 - call $assembly/memory-page/Page#get:raw - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory-page/RawPage#get:data - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - i32.const 0 - i32.ne - if - local.get $currentChunk - i32.const 0 - i32.ne - if - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/api-generic/InitialChunk#get:data - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $v - call $~lib/array/Array#push - drop - else - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-generic/InitialChunk#constructor - local.tee $currentChunk - i32.store offset=24 - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $pageIdx - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.get $n - i32.add - call $assembly/api-generic/InitialChunk#set:address - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - global.get $~lib/memory/__stack_pointer - i32.const 1 - i32.const 0 - i32.const 27 - i32.const 0 - call $~lib/rt/__newArray - local.tee $10 - i32.store offset=28 - local.get $10 - i32.const 0 - local.get $v - call $~lib/array/Array#__set - local.get $10 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/api-generic/InitialChunk#set:data - end - else - local.get $currentChunk - i32.const 0 - i32.ne - if - local.get $chunks - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/array/Array#push - drop - i32.const 0 - local.set $currentChunk - end - end - local.get $n - i32.const 1 - i32.add - local.set $n - br $for-loop|1 - end - end - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $currentChunk - i32.const 0 - i32.ne - if - local.get $chunks - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/array/Array#push - drop - end - local.get $chunks - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $bufferSize i32) - (local $buffer i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 57 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:length_ - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8128 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - local.tee $2 - i32.const 8 - local.tee $3 - local.get $2 - local.get $3 - i32.gt_u - select - i32.const 2 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $bufferSize - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $length - call $~lib/array/Array#set:length_ - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.get $newLength - i32.const 2 - i32.const 0 - call $~lib/array/ensureCapacity - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $newLength - call $~lib/array/Array#set:length_ - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#values" (param $this i32) (result i32) - (local $start i32) - (local $size i32) - (local $values i32) - (local $length i32) - (local $i i32) - (local $entry i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.set $start - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.set $size - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $size - call $~lib/array/Array#constructor - local.tee $values - i32.store offset=4 - i32.const 0 - local.set $length - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $size - i32.lt_s - if - local.get $start - local.get $i - block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.7" - end - i32.mul - i32.add - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - local.tee $7 - i32.const 1 - i32.add - local.set $length - local.get $7 - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/array/Array#__set - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - call $~lib/array/Array#set:length - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory-page/Arena#release (param $this i32) (param $page i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory-page/Arena#get:free - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $page - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/array/Array#push - drop - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#clear" (param $this i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - i32.const 4 - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 4 - i32.const 1 - i32.sub - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - i32.const 4 - block $"~lib/map/ENTRY_SIZE|inlined.8" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.8" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 4 - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesOffset" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesCount" - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#free (param $this i32) - (local $pages i32) - (local $i i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory/Memory#get:pages - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $"~lib/map/Map#values" - local.tee $pages - i32.store offset=8 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pages - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - i32.lt_s - if - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/memory/Memory#get:arena - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $pages - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $3 - local.get $i - call $~lib/array/Array#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/memory-page/Page#get:raw - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#release - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory/Memory#get:pages - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $"~lib/map/Map#clear" - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-generic/runVm (param $input i32) (param $logs i32) (param $useSbrkGas i32) (result i32) - (local $p i32) - (local $registers i32) - (local $r i32) - (local $builder i32) - (local $memory i32) - (local $int i32) - (local $isOk i32) - (local $10 i32) - (local $11 i32) - (local $instruction i32) - (local $iData i32) - (local $skipBytes i32) - (local $name i32) - (local $16 i32) - (local $17 i32) - (local $args i32) - (local $19 i32) - (local $20 i32) - (local $21 i32) - (local $22 i32) - (local $23 i32) - (local $24 i32) - (local $25 i32) - (local $26 i32) - (local $27 i32) - (local $28 i32) - (local $29 i32) - (local $30 i32) - (local $output i32) - (local $32 i32) - global.get $~lib/memory/__stack_pointer - i32.const 124 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 124 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $input - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/api-generic/VmInput#get:program - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/liftBytes - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $assembly/program/deblob - local.tee $p - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=16 - i32.const 0 - local.set $r - loop $for-loop|0 - local.get $r - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $r - local.get $input - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/api-generic/VmInput#get:registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $r - call $~lib/array/Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $r - i32.const 1 - i32.add - local.set $r - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $input - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/api-generic/VmInput#get:pageMap - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $input - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/api-generic/VmInput#get:memory - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/api-generic/buildMemory - local.tee $memory - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $p - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $memory - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/interpreter/Interpreter#constructor - local.tee $int - i32.store offset=32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $useSbrkGas - call $assembly/interpreter/Interpreter#set:useSbrkGas - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $input - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/api-generic/VmInput#get:pc - call $assembly/interpreter/Interpreter#set:nextPc - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:gas - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $input - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/api-generic/VmInput#get:gas - call $assembly/gas/GasCounter#set@override - i32.const 1 - local.set $isOk - block $for-break1 - loop $for-loop|1 - i32.const 1 - if - local.get $isOk - i32.eqz - if - local.get $logs - if - global.get $~lib/memory/__stack_pointer - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 17392 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray#join - local.tee $10 - i32.store offset=36 - i32.const 18128 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 1 - local.get $10 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18128 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 14400 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - global.get $~lib/memory/__stack_pointer - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - i32.const 18192 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=40 - local.get $32 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 17392 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/array/Array<~lib/string/String>#join - local.tee $11 - i32.store offset=44 - i32.const 18160 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 1 - local.get $11 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18160 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 14400 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 18224 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:status - i32.const 10 - call $~lib/number/I32#toString - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/string/String#concat - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - br $for-break1 - end - local.get $logs - if - i32.const 18288 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - i32.const 10 - call $~lib/number/U32#toString - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/string/String#concat - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 18320 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:status - i32.const 10 - call $~lib/number/I32#toString - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/string/String#concat - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 18032 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - i32.const 17392 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=40 - local.get $32 - call $~lib/staticarray/StaticArray#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/string/String#concat - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 18032 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=48 - local.get $32 - i32.const 18368 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=52 - local.get $32 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - i32.const 17392 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=40 - local.get $32 - call $~lib/array/Array<~lib/string/String>#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/string/String#concat - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/interpreter/Interpreter#get:program - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/Program#get:code - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_u - if (result i32) - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/interpreter/Interpreter#get:program - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/Program#get:code - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - call $~lib/typedarray/Uint8Array#__get - else - i32.const 0 - end - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $instruction - call $~lib/array/Array#__get - end - local.set $iData - local.get $p - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/Program#get:mask - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipBytes - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:namePtr - local.tee $name - i32.store offset=56 - global.get $~lib/memory/__stack_pointer - local.get $name - local.tee $16 - i32.store offset=60 - global.get $~lib/memory/__stack_pointer - local.get $instruction - i32.const 10 - call $~lib/number/U8#toString - local.tee $17 - i32.store offset=64 - i32.const 18480 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 1 - local.get $16 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18480 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 3 - local.get $17 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18480 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 14400 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=40 - local.get $32 - call $assembly/interpreter/Interpreter#get:program - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/program/Program#get:code - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - i32.const 1 - i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $skipBytes - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/interpreter/Interpreter#get:registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/resolveArguments - local.tee $args - i32.store offset=68 - local.get $args - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:a - i32.const 10 - call $~lib/number/I64#toString - local.tee $19 - i32.store offset=72 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/program/ResolvedArguments#get:decoded - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/arguments/Args#get:a - i32.const 10 - call $~lib/number/U32#toString - local.tee $20 - i32.store offset=76 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:a - i32.const 16 - call $~lib/number/U64#toString - local.tee $21 - i32.store offset=80 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:b - i32.const 10 - call $~lib/number/I64#toString - local.tee $22 - i32.store offset=84 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/program/ResolvedArguments#get:decoded - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/arguments/Args#get:b - i32.const 10 - call $~lib/number/U32#toString - local.tee $23 - i32.store offset=88 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:b - i32.const 16 - call $~lib/number/U64#toString - local.tee $24 - i32.store offset=92 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:c - i32.const 10 - call $~lib/number/I64#toString - local.tee $25 - i32.store offset=96 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/program/ResolvedArguments#get:decoded - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/arguments/Args#get:c - i32.const 10 - call $~lib/number/U32#toString - local.tee $26 - i32.store offset=100 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:c - i32.const 16 - call $~lib/number/U64#toString - local.tee $27 - i32.store offset=104 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:d - i32.const 10 - call $~lib/number/I64#toString - local.tee $28 - i32.store offset=108 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/program/ResolvedArguments#get:decoded - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/arguments/Args#get:d - i32.const 10 - call $~lib/number/U32#toString - local.tee $29 - i32.store offset=112 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:d - i32.const 16 - call $~lib/number/U64#toString - local.tee $30 - i32.store offset=116 - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 1 - local.get $19 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 3 - local.get $20 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 5 - local.get $21 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 7 - local.get $22 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 9 - local.get $23 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 11 - local.get $24 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 13 - local.get $25 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 15 - local.get $26 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 17 - local.get $27 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 19 - local.get $28 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 21 - local.get $29 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 23 - local.get $30 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 14400 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - end - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $assembly/interpreter/Interpreter#nextStep - local.set $isOk - br $for-loop|1 - end - end - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-generic/VmOutput#constructor - local.tee $output - i32.store offset=120 - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:status - call $assembly/api-generic/VmOutput#set:status - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/api-generic/VmOutput#set:registers - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - call $assembly/api-generic/VmOutput#set:pc - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/interpreter/Interpreter#get:gas - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/gas/GasCounter#get@override - call $assembly/api-generic/VmOutput#set:gas - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:memory - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/api-generic/getOutputChunks - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/api-generic/VmOutput#set:memory - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:exitCode - call $assembly/api-generic/VmOutput#set:exitCode - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:memory - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $assembly/memory/Memory#free - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - i32.const 124 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $32 - return - ) - (func $assembly/index/runProgram (param $input i32) (param $registers i32) (param $kind i32) (result i32) - (local $vmInput i32) - (local $output i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $kind - global.get $assembly/index/InputKind.Generic - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-generic/VmInput#constructor - local.tee $vmInput - i32.store - local.get $vmInput - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/api-generic/VmInput#set:registers - local.get $vmInput - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i64.const 10000 - call $assembly/api-generic/VmInput#set:gas - local.get $vmInput - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $input - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/api-generic/VmInput#set:program - global.get $~lib/memory/__stack_pointer - local.get $vmInput - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - i32.const 0 - call $assembly/api-generic/runVm - local.tee $output - i32.store offset=12 - i32.const 18224 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $output - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/api-generic/VmOutput#get:status - i32.const 10 - call $~lib/number/I32#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $~lib/string/String#concat - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/console/console.log - local.get $output - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $kind - global.get $assembly/index/InputKind.SPI - i32.eq - if - i32.const 19200 - i32.const 19280 - i32.const 57 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - i32.const 17584 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/string/String#concat - i32.const 19280 - i32.const 60 - i32.const 3 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-generic/runVm@varargs (param $input i32) (param $logs i32) (param $useSbrkGas i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $logs - end - i32.const 0 - local.set $useSbrkGas - end - local.get $input - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $logs - local.get $useSbrkGas - call $assembly/api-generic/runVm - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program-build/skipBytes (param $kind i32) (param $data i32) (result i32) - (local $2 i32) - (local $n i32) - (local $split i32) - (local $n|5 i32) - (local $split|6 i32) - (local $n|7 i32) - (local $split|8 i32) - (local $value1 f64) - (local $value2 f64) - (local $value1|11 f64) - (local $value2|12 f64) - (local $n|13 i32) - (local $split|14 i32) - (local $15 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $case13|0 - block $case12|0 - block $case11|0 - block $case10|0 - block $case9|0 - block $case8|0 - block $case7|0 - block $case6|0 - block $case5|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $kind - local.set $2 - local.get $2 - global.get $assembly/arguments/Arguments.Zero - i32.eq - br_if $case0|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneImm - i32.eq - br_if $case1|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoImm - i32.eq - br_if $case2|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneOff - i32.eq - br_if $case3|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegOneImm - i32.eq - br_if $case4|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegOneExtImm - i32.eq - br_if $case5|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i32.eq - br_if $case6|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i32.eq - br_if $case7|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoReg - i32.eq - br_if $case8|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i32.eq - br_if $case9|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i32.eq - br_if $case10|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoRegTwoImm - i32.eq - br_if $case11|0 - local.get $2 - global.get $assembly/arguments/Arguments.ThreeReg - i32.eq - br_if $case12|0 - br $case13|0 - end - i32.const 0 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - call $assembly/program-build/immBytes - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:low - i32.const 1 - i32.add - local.set $split - i32.const 1 - local.get $split - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - local.get $split - i32.const 1 - i32.add - i32.const 255 - i32.and - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - call $assembly/program-build/immBytes - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 9 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n|5 - i32.store offset=8 - local.get $n|5 - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:hig - i32.const 1 - i32.add - local.set $split|6 - i32.const 1 - local.get $split|6 - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - local.get $split|6 - i32.const 255 - i32.and - i32.add - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n|7 - i32.store offset=12 - local.get $n|7 - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:hig - i32.const 1 - i32.add - local.set $split|8 - i32.const 1 - local.get $split|8 - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - local.get $split|8 - i32.const 255 - i32.and - i32.add - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - block $~lib/math/NativeMath.min|inlined.5 (result f64) - f64.const 4 - local.set $value1 - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.5 - end - i32.trunc_sat_f64_s - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - block $~lib/math/NativeMath.min|inlined.6 (result f64) - f64.const 4 - local.set $value1|11 - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - local.set $value2|12 - local.get $value1|11 - local.get $value2|12 - f64.min - br $~lib/math/NativeMath.min|inlined.6 - end - i32.trunc_sat_f64_s - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n|13 - i32.store offset=16 - local.get $n|13 - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:low - i32.const 1 - i32.add - local.set $split|14 - i32.const 2 - local.get $split|14 - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 2 - local.get $split|14 - i32.const 255 - i32.and - i32.add - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 2 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 18528 - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store offset=20 - local.get $15 - call $~lib/string/String#concat - i32.const 19344 - i32.const 73 - i32.const 7 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program-build/buildMask (param $bytecode i32) (result i32) - (local $mask i32) - (local $i i32) - (local $instruction i32) - (local $iData i32) - (local $requiredBytes i32) - (local $6 i32) - (local $packed i32) - (local $i|8 i32) - (local $byte i32) - (local $j i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - call $~lib/staticarray/StaticArray#constructor - local.tee $mask - i32.store offset=4 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/array/Array#get:length - i32.lt_s - if (result i32) - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $instruction - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION - end - local.set $iData - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $i - i32.const 1 - call $~lib/staticarray/StaticArray#__set - global.get $assembly/arguments/REQUIRED_BYTES - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $iData - call $assembly/instructions/Instruction#get:kind - call $~lib/array/Array#__get - local.set $requiredBytes - local.get $i - i32.const 1 - i32.add - local.get $requiredBytes - i32.add - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - i32.le_s - if - local.get $i - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - local.get $i - i32.const 1 - i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $assembly/program-build/skipBytes - i32.add - local.set $i - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 19424 - call $~lib/rt/__newArray - local.tee $packed - i32.store offset=12 - i32.const 0 - local.set $i|8 - loop $for-loop|1 - local.get $i|8 - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - i32.const 0 - local.set $byte - local.get $i|8 - local.set $j - loop $for-loop|3 - local.get $j - local.get $i|8 - i32.const 8 - i32.add - i32.lt_s - if - local.get $byte - i32.const 255 - i32.and - i32.const 1 - i32.const 7 - i32.and - i32.shr_u - local.set $byte - local.get $j - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if (result i32) - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $j - call $~lib/staticarray/StaticArray#__get - else - i32.const 0 - end - if - local.get $byte - i32.const 128 - i32.or - local.set $byte - end - local.get $j - i32.const 1 - i32.add - local.set $j - br $for-loop|3 - end - end - local.get $packed - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $byte - call $~lib/array/Array#push - drop - local.get $i|8 - i32.const 8 - i32.add - local.set $i|8 - br $for-loop|1 - end - end - local.get $packed - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/dataview/DataView#constructor (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) - (local $dataStart i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 59 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/dataview/DataView#set:buffer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/dataview/DataView#set:dataStart - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/dataview/DataView#set:byteLength - local.get $byteLength - i32.const 1073741820 - i32.gt_u - local.get $byteOffset - local.get $byteLength - i32.add - local.get $buffer - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/arraybuffer/ArrayBuffer#get:byteLength - i32.gt_u - i32.or - if - i32.const 8176 - i32.const 19456 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $buffer - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/dataview/DataView#set:buffer - local.get $buffer - local.get $byteOffset - i32.add - local.set $dataStart - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $dataStart - call $~lib/dataview/DataView#set:dataStart - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $byteLength - call $~lib/dataview/DataView#set:byteLength - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $~lib/dataview/DataView#constructor@varargs (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $byteOffset - end - local.get $buffer - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/arraybuffer/ArrayBuffer#get:byteLength - local.set $byteLength - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $buffer - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $byteOffset - local.get $byteLength - call $~lib/dataview/DataView#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/dataview/DataView#setUint64 (param $this i32) (param $byteOffset i32) (param $value i64) (param $littleEndian i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $byteOffset - i32.const 31 - i32.shr_u - local.get $byteOffset - i32.const 8 - i32.add - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/dataview/DataView#get:byteLength - i32.gt_s - i32.or - if - i32.const 480 - i32.const 19456 - i32.const 174 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/dataview/DataView#get:dataStart - local.get $byteOffset - i32.add - local.get $littleEndian - if (result i64) - local.get $value - else - local.get $value - call $~lib/polyfills/bswap - end - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/encodeVarU32 (param $v i64) (result i32) - (local $maxEncoded i64) - (local $dest i32) - (local $dataView i32) - (local $minEncoded i64) - (local $l i32) - (local $dest|6 i32) - (local $maxVal i32) - (local $byte i64) - (local $rest i64) - (local $i i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - local.get $v - i64.const 0 - i64.eq - if - i32.const 0 - i32.const 1 - call $~lib/typedarray/Uint8Array#constructor - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - i64.const 2 - i64.const 7 - i64.const 8 - i64.mul - call $~lib/math/ipow64 - local.set $maxEncoded - local.get $v - local.get $maxEncoded - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 9 - call $~lib/typedarray/Uint8Array#constructor - local.tee $dest - i32.store - local.get $dest - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - i32.const 255 - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $dest - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/dataview/DataView#constructor@varargs - local.tee $dataView - i32.store offset=12 - local.get $dataView - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 1 - local.get $v - i32.const 1 - call $~lib/dataview/DataView#setUint64 - local.get $dest - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $maxEncoded - i64.const 7 - i64.shr_u - local.set $minEncoded - i32.const 7 - local.set $l - loop $for-loop|0 - local.get $l - i32.const 0 - i32.ge_s - if - local.get $v - local.get $minEncoded - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $l - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $dest|6 - i32.store offset=16 - i32.const 2 - i32.const 8 - local.get $l - i32.mul - call $~lib/math/ipow32 - local.set $maxVal - i32.const 2 - i32.const 8 - call $~lib/math/ipow32 - i32.const 2 - i32.const 8 - local.get $l - i32.sub - call $~lib/math/ipow32 - i32.sub - i64.extend_i32_s - local.get $v - local.get $maxVal - i64.extend_i32_s - i64.div_u - i64.add - local.set $byte - local.get $dest|6 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - local.get $byte - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - local.get $maxVal - i64.extend_i32_s - i64.rem_u - local.set $rest - i32.const 1 - local.set $i - loop $for-loop|1 - local.get $i - i32.const 1 - local.get $l - i32.add - i32.lt_s - if - local.get $dest|6 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $i - local.get $rest - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $rest - i64.const 8 - i64.shr_u - local.set $rest - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|1 - end - end - local.get $dest|6 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $minEncoded - local.set $maxEncoded - local.get $minEncoded - i64.const 7 - i64.shr_u - local.set $minEncoded - local.get $l - i32.const 1 - i32.sub - local.set $l - br $for-loop|0 - end - end - i32.const 19520 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $v - i32.const 10 - call $~lib/number/U64#toString - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/string/String#concat - i32.const 16384 - i32.const 160 - i32.const 3 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/program-build/wrapAsProgram (param $bytecode i32) (result i32) - (local $codeLength i32) - (local $mask i32) - (local $codeLengthBytes i32) - (local $data i32) - (local $offset i32) - (local $i i32) - (local $i|7 i32) - (local $i|8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - local.get $bytecode - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.set $codeLength - global.get $~lib/memory/__stack_pointer - local.get $bytecode - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $assembly/program-build/buildMask - local.tee $mask - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $codeLength - i64.extend_i32_s - call $assembly/codec/encodeVarU32 - local.tee $codeLengthBytes - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 1 - i32.add - local.get $codeLengthBytes - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.add - local.get $codeLength - i32.add - local.get $mask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $data - i32.store offset=12 - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set - i32.const 2 - local.set $offset - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $codeLengthBytes - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $offset - local.get $codeLengthBytes - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $offset - i32.const 1 - i32.add - local.set $offset - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $bytecode - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $offset - local.get $bytecode - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - local.get $i|7 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $offset - i32.const 1 - i32.add - local.set $offset - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - i32.const 0 - local.set $i|8 - loop $for-loop|2 - local.get $i|8 - local.get $mask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.lt_s - if - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $offset - local.get $mask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - local.get $i|8 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $offset - i32.const 1 - i32.add - local.set $offset - local.get $i|8 - i32.const 1 - i32.add - local.set $i|8 - br $for-loop|2 - end - end - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $assembly/api/fillRegisters (param $registers i32) (param $flat i32) - (local $len i32) - (local $3 i32) - (local $4 i32) - (local $i i32) - (local $num i64) - (local $j i32) - (local $index i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/staticarray/StaticArray#get:length - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - local.set $len - local.get $len - local.get $flat - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.ne - if - global.get $~lib/memory/__stack_pointer - local.get $flat - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $len - i32.const 10 - call $~lib/number/I32#toString - local.tee $4 - i32.store offset=8 - i32.const 19744 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 1 - local.get $3 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 19744 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 3 - local.get $4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 19744 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 14400 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 19792 - i32.const 166 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - i64.const 0 - local.set $num - i32.const 0 - local.set $j - loop $for-loop|1 - local.get $j - global.get $assembly/registers/REG_SIZE_BYTES - i32.const 255 - i32.and - i32.lt_u - if - local.get $i - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - local.get $j - i32.add - local.set $index - local.get $num - local.get $flat - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $index - call $~lib/array/Array#__get - i64.extend_i32_u - local.get $j - i32.const 8 - i32.mul - i32.const 255 - i32.and - i64.extend_i32_u - i64.shl - i64.or - local.set $num - local.get $j - i32.const 1 - i32.add - local.set $j - br $for-loop|1 - end - end - local.get $registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $i - local.get $num - call $~lib/staticarray/StaticArray#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/interpreter/Interpreter#constructor@varargs (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 2 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $assembly/memory/MemoryBuilder#build - local.tee $memory - i32.store offset=4 - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/interpreter/Interpreter#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/api/resetGeneric (param $program i32) (param $flatRegisters i32) (param $initialGas i64) - (local $p i32) - (local $registers i32) - (local $int i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $program - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - call $assembly/program/liftBytes - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $assembly/program/deblob - local.tee $p - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=12 - local.get $registers - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $flatRegisters - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - call $assembly/api/fillRegisters - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $p - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $registers - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 2 - global.set $~argumentsLength - i32.const 0 - call $assembly/interpreter/Interpreter#constructor@varargs - local.tee $int - i32.store offset=16 - local.get $int - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - call $assembly/interpreter/Interpreter#get:gas - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $initialGas - call $assembly/gas/GasCounter#set@override - local.get $int - global.set $assembly/api/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-generic/InitialPage#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 48 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/api-generic/InitialPage#set:address - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/api-generic/InitialPage#set:length - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/memory-page/Access.None - call $assembly/api-generic/InitialPage#set:access - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api/readPages (param $pageMap i32) (result i32) - (local $1 i32) - (local $pages i32) - (local $codec i32) - (local $p i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 19856 - call $~lib/rt/__newArray - local.tee $pages - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $pageMap - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $codec - i32.store offset=8 - loop $while-continue|0 - local.get $codec - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-generic/InitialPage#constructor - local.tee $p - i32.store offset=12 - local.get $p - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $codec - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/codec/Decoder#u32 - call $assembly/api-generic/InitialPage#set:address - local.get $p - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $codec - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/codec/Decoder#u32 - call $assembly/api-generic/InitialPage#set:length - local.get $p - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $codec - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/codec/Decoder#u8 - i32.const 0 - i32.gt_u - if (result i32) - global.get $assembly/memory-page/Access.Write - else - global.get $assembly/memory-page/Access.Read - end - call $assembly/api-generic/InitialPage#set:access - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $p - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $~lib/array/Array#push - drop - br $while-continue|0 - end - end - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/api/readChunks (param $chunks i32) (result i32) - (local $1 i32) - (local $res i32) - (local $codec i32) - (local $c i32) - (local $len i32) - (local $data i32) - (local $i i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 19888 - call $~lib/rt/__newArray - local.tee $res - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $chunks - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $codec - i32.store offset=8 - loop $while-continue|0 - local.get $codec - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-generic/InitialChunk#constructor - local.tee $c - i32.store offset=12 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $codec - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $assembly/codec/Decoder#u32 - call $assembly/api-generic/InitialChunk#set:address - local.get $codec - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/codec/Decoder#u32 - local.set $len - global.get $~lib/memory/__stack_pointer - local.get $codec - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $len - call $assembly/codec/Decoder#bytes - local.tee $data - i32.store offset=20 - i32.const 0 - local.set $i - loop $for-loop|1 - local.get $i - local.get $len - i32.lt_u - if - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $assembly/api-generic/InitialChunk#get:data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#push - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/array/Array#push - drop - br $while-continue|0 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/api/resetGenericWithMemory (param $program i32) (param $flatRegisters i32) (param $pageMap i32) (param $chunks i32) (param $initialGas i64) - (local $p i32) - (local $registers i32) - (local $builder i32) - (local $memory i32) - (local $int i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $program - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $assembly/program/liftBytes - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/program/deblob - local.tee $p - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=12 - local.get $registers - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $flatRegisters - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $assembly/api/fillRegisters - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $pageMap - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=24 - local.get $10 - call $assembly/api/readPages - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $chunks - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=24 - local.get $10 - call $assembly/api/readChunks - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $10 - call $assembly/api-generic/buildMemory - local.tee $memory - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $p - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $registers - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $memory - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $10 - call $assembly/interpreter/Interpreter#constructor - local.tee $int - i32.store offset=32 - local.get $int - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $assembly/interpreter/Interpreter#get:gas - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $initialGas - call $assembly/gas/GasCounter#set@override - local.get $int - global.set $assembly/api/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/nextStep (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 19792 - i32.const 43 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/interpreter/Interpreter#nextStep - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api/nSteps (param $steps i32) (result i32) - (local $1 i32) - (local $int i32) - (local $isOk i32) - (local $i i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 51 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - i32.const 1 - local.set $isOk - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $steps - i32.lt_u - if - local.get $int - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/interpreter/Interpreter#nextStep - local.set $isOk - local.get $isOk - i32.eqz - if - i32.const 0 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $isOk - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - i32.const 0 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/api/getProgramCounter (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 19792 - i32.const 68 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/interpreter/Interpreter#get:pc - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api/setNextProgramCounter (param $pc i32) - (local $1 i32) - (local $int i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 76 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $pc - call $assembly/interpreter/Interpreter#set:nextPc - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/getStatus (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - global.get $assembly/interpreter/Status.PANIC - i32.const 255 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 19792 - i32.const 84 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/interpreter/Interpreter#get:status - i32.const 255 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api/getExitArg (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - i32.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 19792 - i32.const 92 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/interpreter/Interpreter#get:exitCode - local.tee $2 - if (result i32) - local.get $2 - else - i32.const 0 - end - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/api/getGasLeft (result i64) - (local $0 i32) - (local $int i32) - (local $2 i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - i64.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 19792 - i32.const 100 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - call $assembly/interpreter/Interpreter#get:gas - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/gas/GasCounter#get@override - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/api/setGasLeft (param $gas i64) - (local $1 i32) - (local $int i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 106 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/interpreter/Interpreter#get:gas - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $gas - call $assembly/gas/GasCounter#set@override - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/getRegisters (result i32) - (local $flat i32) - (local $1 i32) - (local $int i32) - (local $i i32) - (local $val i64) - (local $j i32) - (local $index i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - call $~lib/typedarray/Uint8Array#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.tee $flat - i32.store offset=4 - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - local.get $flat - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store offset=8 - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 117 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=12 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $int - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/interpreter/Interpreter#get:registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - local.get $int - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/interpreter/Interpreter#get:registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $i - call $~lib/staticarray/StaticArray#__get - local.set $val - i32.const 0 - local.set $j - loop $for-loop|1 - local.get $j - global.get $assembly/registers/REG_SIZE_BYTES - i32.lt_s - if - local.get $i - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - local.get $j - i32.add - local.set $index - local.get $flat - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $index - local.get $val - i64.const 255 - i64.and - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $val - i64.const 8 - i64.shr_u - local.set $val - local.get $j - i32.const 1 - i32.add - local.set $j - br $for-loop|1 - end - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $flat - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $assembly/api/setRegisters (param $flatRegisters i32) - (local $1 i32) - (local $int i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 134 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $3 - call $assembly/interpreter/Interpreter#get:registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $flatRegisters - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/api/fillRegisters - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#pageDump (param $this i32) (param $index i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory/Memory#get:pages - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $index - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - call $assembly/memory/Memory#get:pages - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - local.get $index - call $"~lib/map/Map#get" - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory-page/Page#get:raw - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:data - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api/getPageDump (param $index i32) (result i32) - (local $1 i32) - (local $int i32) - (local $page i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store offset=4 - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 142 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $int - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/interpreter/Interpreter#get:memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $index - call $assembly/memory/Memory#pageDump - local.tee $page - i32.store offset=16 - local.get $page - i32.const 0 - i32.eq - if - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $page - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api/setMemory (param $address i32) (param $data i32) - (local $2 i32) - (local $int i32) - (local $end i32) - (local $i i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $2 - i32.store - local.get $2 - if (result i32) - local.get $2 - else - i32.const 9488 - i32.const 19792 - i32.const 155 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $address - local.get $data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $~lib/typedarray/Uint8Array#get:length - i32.add - local.set $end - local.get $address - local.set $i - loop $for-loop|0 - local.get $i - local.get $end - i32.lt_u - if - local.get $int - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/interpreter/Interpreter#get:memory - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $i - local.get $data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $i - local.get $address - i32.sub - call $~lib/typedarray/Uint8Array#__get - call $assembly/memory/Memory#setU8 - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/gas/GasCounterU64#set (param $this i32) (param $g i64) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $g - call $assembly/gas/GasCounterU64#set:gas - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/gas/GasCounterU64#sub (param $this i32) (param $g i64) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/gas/GasCounterU64#get:gas - local.get $g - i64.sub - call $assembly/gas/GasCounterU64#set:gas - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/gas/GasCounterU64#get:gas - i64.const 0 - i64.lt_s - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/gas/GasCounterU64#get (param $this i32) (result i64) - (local $1 i32) - (local $2 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/gas/GasCounterU64#get:gas - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#__visit" (param $this i32) (param $cookie i32) - (local $entries i32) - (local $cur i32) - (local $end i32) - (local $entry i32) - (local $val i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:buckets" - local.get $cookie - call $~lib/rt/itcms/__visit - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:entries" - local.set $entries - i32.const 1 - drop - local.get $entries - local.set $cur - local.get $cur - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.9" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.9" - end - i32.mul - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - drop - i32.const 1 - drop - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $val - i32.const 0 - drop - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - block $"~lib/map/ENTRY_SIZE|inlined.10" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.10" - end - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $entries - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28u8%29=>u8>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28u8%29=>u8>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/object/Object#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/rt/__newArray (param $length i32) (param $alignLog2 i32) (param $id i32) (param $data i32) (result i32) - (local $bufferSize i32) - (local $buffer i32) - (local $array i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - local.get $alignLog2 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - local.get $data - call $~lib/rt/__newBuffer - local.tee $buffer - i32.store - i32.const 16 - local.get $id - call $~lib/rt/itcms/__new - local.set $array - local.get $array - local.get $buffer - i32.store - local.get $array - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - local.get $array - local.get $buffer - i32.store offset=4 - local.get $array - local.get $bufferSize - i32.store offset=8 - local.get $array - local.get $length - i32.store offset=12 - local.get $array - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 0 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 0 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 23 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/arraybuffer/ArrayBuffer#constructor (param $this i32) (param $length i32) (result i32) - (local $buffer i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.gt_u - if - i32.const 8176 - i32.const 8224 - i32.const 52 - i32.const 43 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $buffer - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/util/number/utoa32 (param $value i32) (param $radix i32) (result i32) - (local $out i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|7 i32) - (local $buffer|8 i32) - (local $num|9 i32) - (local $offset|10 i32) - (local $decimals|11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 14608 - i32.const 14736 - i32.const 350 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i32.eqz - if - i32.const 14800 - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer - local.get $value - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 31 - local.get $value - i32.clz - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|7 - global.get $~lib/memory/__stack_pointer - local.get $decimals|7 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|8 - local.get $value - local.set $num|9 - local.get $decimals|7 - local.set $offset|10 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|8 - local.get $num|9 - i64.extend_i32_u - local.get $offset|10 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - i64.extend_i32_u - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|11 - global.get $~lib/memory/__stack_pointer - local.get $decimals|11 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $value - i64.extend_i32_u - local.get $decimals|11 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $out - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $~lib/util/number/itoa32 (param $value i32) (param $radix i32) (result i32) - (local $sign i32) - (local $out i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|8 i32) - (local $buffer|9 i32) - (local $num|10 i32) - (local $offset|11 i32) - (local $val32 i32) - (local $decimals|13 i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 14608 - i32.const 14736 - i32.const 373 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i32.eqz - if - i32.const 14800 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $value - i32.const 31 - i32.shr_u - i32.const 1 - i32.shl - local.set $sign - local.get $sign - if - i32.const 0 - local.get $value - i32.sub - local.set $value - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer - local.get $value - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 31 - local.get $value - i32.clz - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|8 - global.get $~lib/memory/__stack_pointer - local.get $decimals|8 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|9 - local.get $value - local.set $num|10 - local.get $decimals|8 - local.set $offset|11 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|9 - local.get $num|10 - i64.extend_i32_u - local.get $offset|11 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.set $val32 - local.get $val32 - i64.extend_i32_u - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|13 - global.get $~lib/memory/__stack_pointer - local.get $decimals|13 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.get $val32 - i64.extend_i32_u - local.get $decimals|13 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $sign - if - local.get $out - i32.const 45 - i32.store16 - end - local.get $out - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 2 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 32 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 3 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 3 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 14 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 2 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 35 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/util/number/utoa64 (param $value i64) (param $radix i32) (result i32) - (local $out i32) - (local $val32 i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|8 i32) - (local $buffer|9 i32) - (local $num|10 i64) - (local $offset|11 i32) - (local $decimals|12 i32) - (local $buffer|13 i32) - (local $num|14 i64) - (local $offset|15 i32) - (local $decimals|16 i32) - (local $17 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 14608 - i32.const 14736 - i32.const 401 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i64.const 0 - i64.ne - i32.eqz - if - i32.const 14800 - local.set $17 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $17 - return - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - call $~lib/util/number/decimalCount64High - local.set $decimals|8 - global.get $~lib/memory/__stack_pointer - local.get $decimals|8 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|9 - local.get $value - local.set $num|10 - local.get $decimals|8 - local.set $offset|11 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|9 - local.get $num|10 - local.get $offset|11 - call $~lib/util/number/utoa64_dec_lut - end - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 63 - local.get $value - i64.clz - i32.wrap_i64 - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|12 - global.get $~lib/memory/__stack_pointer - local.get $decimals|12 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|13 - local.get $value - local.set $num|14 - local.get $decimals|12 - local.set $offset|15 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|13 - local.get $num|14 - local.get $offset|15 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|16 - global.get $~lib/memory/__stack_pointer - local.get $decimals|16 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $value - local.get $decimals|16 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $out - local.set $17 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $17 - return - ) - (func $~lib/util/number/itoa64 (param $value i64) (param $radix i32) (result i32) - (local $sign i32) - (local $out i32) - (local $val32 i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|9 i32) - (local $buffer|10 i32) - (local $num|11 i64) - (local $offset|12 i32) - (local $decimals|13 i32) - (local $buffer|14 i32) - (local $num|15 i64) - (local $offset|16 i32) - (local $decimals|17 i32) - (local $18 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 14608 - i32.const 14736 - i32.const 431 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i64.const 0 - i64.ne - i32.eqz - if - i32.const 14800 - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - end - local.get $value - i64.const 63 - i64.shr_u - i32.wrap_i64 - i32.const 1 - i32.shl - local.set $sign - local.get $sign - if - i64.const 0 - local.get $value - i64.sub - local.set $value - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - call $~lib/util/number/decimalCount64High - local.set $decimals|9 - global.get $~lib/memory/__stack_pointer - local.get $decimals|9 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|10 - local.get $value - local.set $num|11 - local.get $decimals|9 - local.set $offset|12 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|10 - local.get $num|11 - local.get $offset|12 - call $~lib/util/number/utoa64_dec_lut - end - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 63 - local.get $value - i64.clz - i32.wrap_i64 - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|13 - global.get $~lib/memory/__stack_pointer - local.get $decimals|13 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|14 - local.get $value - local.set $num|15 - local.get $decimals|13 - local.set $offset|16 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|14 - local.get $num|15 - local.get $offset|16 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|17 - global.get $~lib/memory/__stack_pointer - local.get $decimals|17 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.get $value - local.get $decimals|17 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $sign - if - local.get $out - i32.const 45 - i32.store16 - end - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 0 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 0 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 58 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $export:assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - call $assembly/index/disassemble - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $export:assembly/index/runProgram (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - local.get $2 - call $assembly/index/runProgram - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $export:assembly/api-generic/runVm@varargs (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - call $assembly/api-generic/runVm@varargs - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $export:assembly/api-generic/getAssembly (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/api-generic/getAssembly - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/program-build/wrapAsProgram - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $export:assembly/api/resetGeneric (param $0 i32) (param $1 i32) (param $2 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - local.get $2 - call $assembly/api/resetGeneric - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $0 - local.get $1 - local.get $2 - local.get $3 - local.get $4 - call $assembly/api/resetGenericWithMemory - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api/setRegisters (param $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/api/setRegisters - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api/setMemory (param $0 i32) (param $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $0 - local.get $1 - call $assembly/api/setMemory - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) -) diff --git a/dist/release.d.ts b/dist/release.d.ts deleted file mode 100644 index 97c330c..0000000 --- a/dist/release.d.ts +++ /dev/null @@ -1,182 +0,0 @@ -/** Exported memory */ -export declare const memory: WebAssembly.Memory; -/** assembly/index/InputKind */ -export declare enum InputKind { - /** @type `i32` */ - Generic, - /** @type `i32` */ - SPI, -} -/** assembly/index/HasMetadata */ -export declare enum HasMetadata { - /** @type `i32` */ - Yes, - /** @type `i32` */ - No, -} -/** - * assembly/index/disassemble - * @param input `~lib/array/Array` - * @param kind `i32` - * @param withMetadata `i32` - * @returns `~lib/string/String` - */ -export declare function disassemble(input: Array, kind: number, withMetadata: number): string; -/** - * assembly/index/runProgram - * @param input `~lib/array/Array` - * @param registers `~lib/array/Array` - * @param kind `i32` - * @returns `assembly/api-generic/VmOutput` - */ -export declare function runProgram(input: Array, registers: Array, kind: number): __Record44; -/** - * assembly/api-generic/runVm - * @param input `assembly/api-generic/VmInput` - * @param logs `bool` - * @param useSbrkGas `bool` - * @returns `assembly/api-generic/VmOutput` - */ -export declare function runVm(input: __Record47, logs?: boolean, useSbrkGas?: boolean): __Record44; -/** - * assembly/api-generic/getAssembly - * @param p `assembly/program/Program` - * @returns `~lib/string/String` - */ -export declare function getAssembly(p: __Internref30): string; -/** - * assembly/program-build/wrapAsProgram - * @param bytecode `~lib/typedarray/Uint8Array` - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array; -/** - * assembly/api/resetGeneric - * @param program `~lib/array/Array` - * @param flatRegisters `~lib/array/Array` - * @param initialGas `i64` - */ -export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint): void; -/** - * assembly/api/resetGenericWithMemory - * @param program `~lib/array/Array` - * @param flatRegisters `~lib/array/Array` - * @param pageMap `~lib/typedarray/Uint8Array` - * @param chunks `~lib/typedarray/Uint8Array` - * @param initialGas `i64` - */ -export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint): void; -/** - * assembly/api/nextStep - * @returns `bool` - */ -export declare function nextStep(): boolean; -/** - * assembly/api/nSteps - * @param steps `u32` - * @returns `bool` - */ -export declare function nSteps(steps: number): boolean; -/** - * assembly/api/getProgramCounter - * @returns `u32` - */ -export declare function getProgramCounter(): number; -/** - * assembly/api/setNextProgramCounter - * @param pc `u32` - */ -export declare function setNextProgramCounter(pc: number): void; -/** - * assembly/api/getStatus - * @returns `u8` - */ -export declare function getStatus(): number; -/** - * assembly/api/getExitArg - * @returns `u32` - */ -export declare function getExitArg(): number; -/** - * assembly/api/getGasLeft - * @returns `i64` - */ -export declare function getGasLeft(): bigint; -/** - * assembly/api/setGasLeft - * @param gas `i64` - */ -export declare function setGasLeft(gas: bigint): void; -/** - * assembly/api/getRegisters - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function getRegisters(): Uint8Array; -/** - * assembly/api/setRegisters - * @param flatRegisters `~lib/array/Array` - */ -export declare function setRegisters(flatRegisters: Array): void; -/** - * assembly/api/getPageDump - * @param index `u32` - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function getPageDump(index: number): Uint8Array; -/** - * assembly/api/setMemory - * @param address `u32` - * @param data `~lib/typedarray/Uint8Array` - */ -export declare function setMemory(address: number, data: Uint8Array): void; -/** assembly/api-generic/InitialChunk */ -declare interface __Record45 { - /** @type `u32` */ - address: number | TOmittable; - /** @type `~lib/array/Array` */ - data: Array; -} -/** assembly/api-generic/VmOutput */ -declare interface __Record44 { - /** @type `i32` */ - status: number | TOmittable; - /** @type `~lib/array/Array` */ - registers: Array; - /** @type `u32` */ - pc: number | TOmittable; - /** @type `~lib/array/Array` */ - memory: Array<__Record45>; - /** @type `i64` */ - gas: bigint | TOmittable; - /** @type `u32` */ - exitCode: number | TOmittable; -} -/** assembly/api-generic/InitialPage */ -declare interface __Record48 { - /** @type `u32` */ - address: number | TOmittable; - /** @type `u32` */ - length: number | TOmittable; - /** @type `i32` */ - access: number | TOmittable; -} -/** assembly/api-generic/VmInput */ -declare interface __Record47 { - /** @type `~lib/array/Array` */ - registers: Array; - /** @type `u32` */ - pc: number | TOmittable; - /** @type `i64` */ - gas: bigint | TOmittable; - /** @type `~lib/array/Array` */ - program: Array; - /** @type `~lib/array/Array` */ - pageMap: Array<__Record48>; - /** @type `~lib/array/Array` */ - memory: Array<__Record45>; -} -/** assembly/program/Program */ -declare class __Internref30 extends Number { - private __nominal30: symbol; - private __nominal0: symbol; -} diff --git a/dist/release.js b/dist/release.js deleted file mode 100644 index f4db6ff..0000000 --- a/dist/release.js +++ /dev/null @@ -1,372 +0,0 @@ -async function instantiate(module, imports = {}) { - const adaptedImports = { - env: Object.setPrototypeOf({ - abort(message, fileName, lineNumber, columnNumber) { - // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void - message = __liftString(message >>> 0); - fileName = __liftString(fileName >>> 0); - lineNumber = lineNumber >>> 0; - columnNumber = columnNumber >>> 0; - (() => { - // @external.js - throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); - })(); - }, - "console.log"(text) { - // ~lib/bindings/dom/console.log(~lib/string/String) => void - text = __liftString(text >>> 0); - console.log(text); - }, - }, Object.assign(Object.create(globalThis), imports.env || {})), - }; - const { exports } = await WebAssembly.instantiate(module, adaptedImports); - const memory = exports.memory || imports.env.memory; - const adaptedExports = Object.setPrototypeOf({ - InputKind: (values => ( - // assembly/index/InputKind - values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", - values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", - values - ))({}), - HasMetadata: (values => ( - // assembly/index/HasMetadata - values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", - values[values.No = exports["HasMetadata.No"].valueOf()] = "No", - values - ))({}), - disassemble(input, kind, withMetadata) { - // assembly/index/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String - input = __lowerArray(__setU8, 27, 0, input) || __notnull(); - return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); - }, - runProgram(input, registers, kind) { - // assembly/index/runProgram(~lib/array/Array, ~lib/array/Array, i32) => assembly/api-generic/VmOutput - input = __retain(__lowerArray(__setU8, 27, 0, input) || __notnull()); - registers = __lowerArray(__setU64, 43, 3, registers) || __notnull(); - try { - return __liftRecord44(exports.runProgram(input, registers, kind) >>> 0); - } finally { - __release(input); - } - }, - runVm(input, logs, useSbrkGas) { - // assembly/api-generic/runVm(assembly/api-generic/VmInput, bool?, bool?) => assembly/api-generic/VmOutput - input = __lowerRecord47(input) || __notnull(); - logs = logs ? 1 : 0; - useSbrkGas = useSbrkGas ? 1 : 0; - exports.__setArgumentsLength(arguments.length); - return __liftRecord44(exports.runVm(input, logs, useSbrkGas) >>> 0); - }, - getAssembly(p) { - // assembly/api-generic/getAssembly(assembly/program/Program) => ~lib/string/String - p = __lowerInternref(p) || __notnull(); - return __liftString(exports.getAssembly(p) >>> 0); - }, - wrapAsProgram(bytecode) { - // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array - bytecode = __lowerTypedArray(Uint8Array, 5, 0, bytecode) || __notnull(); - return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0); - }, - resetGeneric(program, flatRegisters, initialGas) { - // assembly/api/resetGeneric(~lib/array/Array, ~lib/array/Array, i64) => void - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); - initialGas = initialGas || 0n; - try { - exports.resetGeneric(program, flatRegisters, initialGas); - } finally { - __release(program); - } - }, - resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas) { - // assembly/api/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64) => void - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - flatRegisters = __retain(__lowerArray(__setU8, 27, 0, flatRegisters) || __notnull()); - pageMap = __retain(__lowerTypedArray(Uint8Array, 5, 0, pageMap) || __notnull()); - chunks = __lowerTypedArray(Uint8Array, 5, 0, chunks) || __notnull(); - initialGas = initialGas || 0n; - try { - exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas); - } finally { - __release(program); - __release(flatRegisters); - __release(pageMap); - } - }, - nextStep() { - // assembly/api/nextStep() => bool - return exports.nextStep() != 0; - }, - nSteps(steps) { - // assembly/api/nSteps(u32) => bool - return exports.nSteps(steps) != 0; - }, - getProgramCounter() { - // assembly/api/getProgramCounter() => u32 - return exports.getProgramCounter() >>> 0; - }, - getExitArg() { - // assembly/api/getExitArg() => u32 - return exports.getExitArg() >>> 0; - }, - setGasLeft(gas) { - // assembly/api/setGasLeft(i64) => void - gas = gas || 0n; - exports.setGasLeft(gas); - }, - getRegisters() { - // assembly/api/getRegisters() => ~lib/typedarray/Uint8Array - return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); - }, - setRegisters(flatRegisters) { - // assembly/api/setRegisters(~lib/array/Array) => void - flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); - exports.setRegisters(flatRegisters); - }, - getPageDump(index) { - // assembly/api/getPageDump(u32) => ~lib/typedarray/Uint8Array - return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); - }, - setMemory(address, data) { - // assembly/api/setMemory(u32, ~lib/typedarray/Uint8Array) => void - data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); - exports.setMemory(address, data); - }, - }, exports); - function __liftRecord45(pointer) { - // assembly/api-generic/InitialChunk - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - address: __getU32(pointer + 0), - data: __liftArray(__getU8, 0, __getU32(pointer + 4)), - }; - } - function __liftRecord44(pointer) { - // assembly/api-generic/VmOutput - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - status: __getI32(pointer + 0), - registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), - pc: __getU32(pointer + 8), - memory: __liftArray(pointer => __liftRecord45(__getU32(pointer)), 2, __getU32(pointer + 12)), - gas: __getI64(pointer + 16), - exitCode: __getU32(pointer + 24), - }; - } - function __lowerRecord48(value) { - // assembly/api-generic/InitialPage - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(12, 48)); - __setU32(pointer + 0, value.address); - __setU32(pointer + 4, value.length); - __setU32(pointer + 8, value.access); - exports.__unpin(pointer); - return pointer; - } - function __lowerRecord45(value) { - // assembly/api-generic/InitialChunk - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(8, 45)); - __setU32(pointer + 0, value.address); - __setU32(pointer + 4, __lowerArray(__setU8, 27, 0, value.data) || __notnull()); - exports.__unpin(pointer); - return pointer; - } - function __lowerRecord47(value) { - // assembly/api-generic/VmInput - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(28, 47)); - __setU32(pointer + 0, __lowerArray(__setU64, 43, 3, value.registers) || __notnull()); - __setU32(pointer + 4, value.pc); - __setU64(pointer + 8, value.gas || 0n); - __setU32(pointer + 16, __lowerArray(__setU8, 27, 0, value.program) || __notnull()); - __setU32(pointer + 20, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, value.pageMap) || __notnull()); - __setU32(pointer + 24, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord45(value) || __notnull()); }, 46, 2, value.memory) || __notnull()); - exports.__unpin(pointer); - return pointer; - } - function __liftString(pointer) { - if (!pointer) return null; - const - end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, - memoryU16 = new Uint16Array(memory.buffer); - let - start = pointer >>> 1, - string = ""; - while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); - return string + String.fromCharCode(...memoryU16.subarray(start, end)); - } - function __liftArray(liftElement, align, pointer) { - if (!pointer) return null; - const - dataStart = __getU32(pointer + 4), - length = __dataview.getUint32(pointer + 12, true), - values = new Array(length); - for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0)); - return values; - } - function __lowerArray(lowerElement, id, align, values) { - if (values == null) return 0; - const - length = values.length, - buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, - header = exports.__pin(exports.__new(16, id)) >>> 0; - __setU32(header + 0, buffer); - __dataview.setUint32(header + 4, buffer, true); - __dataview.setUint32(header + 8, length << align, true); - __dataview.setUint32(header + 12, length, true); - for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]); - exports.__unpin(buffer); - exports.__unpin(header); - return header; - } - function __liftTypedArray(constructor, pointer) { - if (!pointer) return null; - return new constructor( - memory.buffer, - __getU32(pointer + 4), - __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT - ).slice(); - } - function __lowerTypedArray(constructor, id, align, values) { - if (values == null) return 0; - const - length = values.length, - buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, - header = exports.__new(12, id) >>> 0; - __setU32(header + 0, buffer); - __dataview.setUint32(header + 4, buffer, true); - __dataview.setUint32(header + 8, length << align, true); - new constructor(memory.buffer, buffer, length).set(values); - exports.__unpin(buffer); - return header; - } - class Internref extends Number {} - function __lowerInternref(value) { - if (value == null) return 0; - if (value instanceof Internref) return value.valueOf(); - throw TypeError("internref expected"); - } - const refcounts = new Map(); - function __retain(pointer) { - if (pointer) { - const refcount = refcounts.get(pointer); - if (refcount) refcounts.set(pointer, refcount + 1); - else refcounts.set(exports.__pin(pointer), 1); - } - return pointer; - } - function __release(pointer) { - if (pointer) { - const refcount = refcounts.get(pointer); - if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer); - else if (refcount) refcounts.set(pointer, refcount - 1); - else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`); - } - } - function __notnull() { - throw TypeError("value must not be null"); - } - let __dataview = new DataView(memory.buffer); - function __setU8(pointer, value) { - try { - __dataview.setUint8(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setUint8(pointer, value, true); - } - } - function __setU32(pointer, value) { - try { - __dataview.setUint32(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setUint32(pointer, value, true); - } - } - function __setU64(pointer, value) { - try { - __dataview.setBigUint64(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setBigUint64(pointer, value, true); - } - } - function __getU8(pointer) { - try { - return __dataview.getUint8(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getUint8(pointer, true); - } - } - function __getI32(pointer) { - try { - return __dataview.getInt32(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getInt32(pointer, true); - } - } - function __getU32(pointer) { - try { - return __dataview.getUint32(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getUint32(pointer, true); - } - } - function __getI64(pointer) { - try { - return __dataview.getBigInt64(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getBigInt64(pointer, true); - } - } - function __getU64(pointer) { - try { - return __dataview.getBigUint64(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getBigUint64(pointer, true); - } - } - return adaptedExports; -} -export const { - memory, - InputKind, - HasMetadata, - disassemble, - runProgram, - runVm, - getAssembly, - wrapAsProgram, - resetGeneric, - resetGenericWithMemory, - nextStep, - nSteps, - getProgramCounter, - setNextProgramCounter, - getStatus, - getExitArg, - getGasLeft, - setGasLeft, - getRegisters, - setRegisters, - getPageDump, - setMemory, -} = await (async url => instantiate( - await (async () => { - const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); - if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } - else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } - })(), { - } -))(new URL("release.wasm", import.meta.url)); diff --git a/dist/release.wasm b/dist/release.wasm deleted file mode 100644 index 5dbaeb3b3175e196f275a6e9299e4947e9fcf099..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 93361 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 I=Ge^t0d}!nbN~PV diff --git a/dist/release.wasm.map b/dist/release.wasm.map deleted file mode 100644 index 16de3d7..0000000 --- a/dist/release.wasm.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/api.ts","assembly/index.ts","~lib/number.ts","~lib/string.ts","~lib/memory.ts","assembly/api-generic.ts","assembly/gas.ts","assembly/program-build.ts","~lib/dataview.ts","~lib/function.ts"],"names":[],"mappings":"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zCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAGA,EAAO,E,EACY,E,GAAjB,EACmB,EAAb,CAAF,E,GAAsC,EAAb,E,GAAA,EAA7B,E,OAAsD,EAAP,EACb,EAAa,EAAvC,CAAR,E,0DAMK,E,KAAU,EAAa,EC9DrB,MAAN,CADQ,M,CAEA,EAAR,CAAc,MAAd,CAAL,IACU,EAAL,C,CACA,M,CAAL,IACU,EAAL,C,CACA,M,CAAL,IACU,EAAL,C,CDwDI,EAAgC,EAAhC,C,uMVmVC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,6CUjVO,E,KAAU,EAAa,ECnE1B,MAAN,CADQ,M,CAEA,EAAR,CAAc,MAAd,CAAL,IACU,EAAL,C,CACA,M,CAAL,IACU,EAAL,C,CACA,M,CAAL,IACU,EAAL,C,CD6DS,EAAZ,EACI,CAAJ,EAA4B,I,aACrB,E,sDX9EA,E,QAAgB,EAAhB,G,KAAgC,KAAgB,E,KAAhB,E,0DPkLG,M,mCACjC,E,YAAgB,E,KAAA,EoBhJ0B,EAAP,E,KAAJ,CAAlC,EACsC,EAAO,E,KAAX,CAAlC,EAGF,CADgB,EAGV,EAAN,GACA,EACQ,EAAM,EAAd,CAHF,I,uFb7BE,E,QAAA,CAAJ,E,EACE,E,GAA2B,GAAf,E,eAAA,E,2BAEP,E,kBAAA,E,8DC8UH,E,IAAA,CAAJ,E,EACoB,E,+CAvBD,EAAU,GAAV,CAAnB,EADoB,EAAW,EAAf,CAAhB,EAE6B,EAAX,CAAlB,E,EAEK,E,mBAAe,EAAf,EAAD,CAAJ,EAC4B,EAAN,E,WAAkB,E,SAAY,EAA3C,EAAP,G,EAGW,E,mBAAe,EAAf,E,OACR,E,KAAS,EAAT,EAAD,CAAJ,E,EACkB,EAAN,E,OACV,E,KAAa,E,KACO,E,KAAG,E,SAAY,EAA5B,EAAP,G,EAGkB,E,OAAe,E,OAAM,EAAlC,G,gBAaH,E,oBAAJ,E,EACoB,E,uCAII,E,QAAxB,E,KAEqC,CAAlB,CAAnB,EACoC,GAAb,CAGvB,E,IACgB,E,iBAAA,E,WAAuB,EAAiB,EAAxC,I,KACI,E,OAAe,E,WAA1B,E,GAGkB,E,KAAU,CAAV,C,CAAwB,M,CAA7B,CAA6C,EAA7C,CAAtB,EACyC,EAAjB,CAAxB,E,EACK,E,mBAAe,EAAf,EAAD,CAAJ,EAC0B,EAAN,E,OAGD,E,mBAAe,EAAf,E,OACd,E,KAAe,EAAf,EAAD,CAAJ,E,EACkB,EAAN,E,OACV,E,KAAa,E,UAII,E,iBAAA,E,eAAuB,EAAvB,I,OACC,E,iBAAA,E,WAA6B,EAAG,E,KAAkB,CAAlB,CAA+B,GAA/B,CAAhC,I,KACF,E,OAAe,E,KAAY,E,SAAtC,E,2CAnCE,G,uLK5Rc,E,GAAnB,E,EAhCgD,EAA7C,IAgCH,CAAJ,EAAyD,G,eACzD,E,KAAY,EAIH,CAJU,EAInB,G,4CL8TY,E,OAAe,EAAQ,EAAS,EAAhC,E,6BACZ,E,uDAzXyD,EAAhB,G,yHAkYX,CAApB,G,cACA,EAAZ,E,EACgB,EAAI,EAAJ,C,kBACV,E,EAAW,EAAN,EAAT,EADuB,E,GAAA,E,IAGZ,EAAR,E,WAAe,EAAJ,G,kBACJ,EAAN,G,EAAkB,EAAP,EAAf,EADiC,E,GAAA,E,8CAV1B,E,2HA9YC,E,UACc,E,6EKsDC,E,GAAnB,E,EAjBgD,EAA7C,IAiBH,CAAJ,EAAyD,G,aACrC,EAA2B,EAA3B,CAAR,G,wDL0EA,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,YAEF,E,sDE3FC,E,OACN,E,QAAJ,E,EACE,E,KAAY,E,KAGZ,E,KAAW,E,KAAqB,EAAsB,E,KAA3C,C,KACX,E,KAAa,E,qBAER,E,wDO1DQ,E,KAAa,E,YAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL+DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK/DL,G,EAEe,E,iBAAV,E,wDTsLO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAoB,E,mBAAU,EAAV,EI5IT,CAAR,C,WJ8IE,E,wDSvLM,E,KAAa,E,YAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLsDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKtDL,G,EAEe,E,iBAAV,E,0DToIO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,EAAf,EAAsB,E,CAAvB,C,YAEH,E,wDStIM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL6CQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK7CL,G,EAEe,E,iBAAV,E,wDT8KO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACc,E,iBAAU,EAAd,E,EACC,E,iBAAU,EAAd,EAAqB,EAArB,C,CAAL,E,EACA,E,KAAqB,EInJV,CAAR,C,WJqJE,E,wDSjLM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLoCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKpCL,G,EAEe,E,iBAAV,E,0DT6HO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,EAAf,EAAsB,E,CAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,EAAf,EAAsB,E,CAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,EAAf,EAAsB,E,CAAvB,C,YAEH,E,wDSjIM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL2BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK3BL,G,EAEe,E,iBAAV,E,wDTwKO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACc,E,iBAAU,EAAd,E,EACC,E,iBAAU,EAAd,EAAqB,EAArB,C,GACI,E,iBAAU,EAAd,EAAqB,EAArB,C,GACI,E,iBAAU,EAAd,EAAqB,EAArB,C,CAAL,E,EACA,E,KAAqB,EI5JlB,C,WJ8JE,E,wDS7KM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLkBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTwHO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDShIM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/EgB,CAAlD,EAAK,EAAL,EU+EoB,EAAzB,G,EAE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CAAlD,EAAK,EAAL,EUkJ0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZjLO,E,6Da9CP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KX6EJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EW7EI,G,EX6EkB,CAAlD,EAAK,EAAL,EW7EkB,EAAzB,Eb8CO,E,sDaxCH,E,KAAc,E,KXuEiB,E,EWvEjB,G,EXuEuC,CAAlD,EAAK,EAAL,EWvEH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EXiE1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GWjEb,GbuCK,E,sDahCH,E,KAAc,E,KX+DiB,E,EW/DjB,G,EX+DuC,CAAlD,EAAK,EAAL,EW/DH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EXyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GWzDb,Gb+BK,E,6DaxBH,E,KAAc,E,KXuDiB,E,EWvDjB,G,EXuDuC,CAAlD,EAAK,EAAL,EWvDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KXsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EWtDM,G,EXsDgB,CAAlD,EAAK,EAAL,EWtDoB,EAAzB,GbuBK,E,6DahBH,E,KAAc,E,KX+CiB,E,EW/CjB,G,EX+CuC,CAAlD,EAAK,EAAL,EW/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KX8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EW9CM,G,EX8CgB,CAAlD,EAAK,EAAL,EW9CoB,EAAzB,GbeK,E,6Dc9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZ6EL,E,EY7EK,G,EZ6EiB,CAAlD,EAAK,EAAL,EY7EwB,E,IAAiC,EZwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EY7EwB,E,EZwEhB,GYvBN,CAjDT,Ed8CO,E,6DcxCP,E,YAAS,G,IAAoC,E,KZkE9B,G,IYlEuC,E,KAAS,E,KZuE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EYvE4B,G,EZuEN,CAAlD,EAAK,EAAL,EYvE+C,EA2C7C,CA3CT,EdwCO,E,6DclCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZiE1B,E,EYjE0B,G,EZiEJ,CAAlD,EAAK,EAAL,E,EYjEyC,C,IAA4B,EAyCtD,G,EZwBa,E,EAAsB,CAAlD,EAAK,EAAL,EYjEyC,E,EAyC1B,GAAb,CZmBF,CY5DP,EdkCO,E,6Dc5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,KZ2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EYxBY,E,EZwBgB,E,EY3DuC,G,EZ2DjB,CAAlD,EAAK,EAAL,E,EY3DsD,CAmCpD,CZmBF,CYtDP,Ed4BO,E,6DctBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZqDL,E,EYrDK,G,EZqDiB,CAAlD,EAAK,EAAL,EYrDwB,E,IAAmB,E,KAAS,E,KZqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EYrDwB,E,EZqDI,E,EYrDwB,G,EZqDF,CAAlD,EAAK,EAAL,EYrD2C,EAiCzC,CAjCT,EdsBO,E,6DchBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZ+C1B,E,EY/C0B,G,EZ+CJ,CAAlD,EAAK,EAAL,E,EY/CyC,C,IAA4B,E,KAAS,E,KZ+ClD,E,EAAsB,CAAlD,EAAK,EAAL,EY/CyC,E,EZ+Cb,E,EY/CkD,G,EZ+C5B,CAAlD,EAAK,EAAL,E,EY/CiE,CA+B/D,CZWF,CY1CP,EdgBO,E,6DcVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZyCL,E,EYzCK,G,EZyCiB,CAAlD,EAAK,EAAL,EYzCwB,E,IAAmB,E,KAAS,E,KZyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EYzCwB,E,EZyCI,E,EYzCwB,G,EZyCF,CAAlD,EAAK,EAAL,EYzC2C,EAazC,CAbT,EdUO,E,6DcJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZmC1B,E,EYnC0B,G,EZmCJ,CAAlD,EAAK,EAAL,E,EYnCyC,C,IAA4B,E,KAAS,E,KZmClD,E,EAAsB,CAAlD,EAAK,EAAL,EYnCyC,E,EZmCb,E,EYnCkD,G,EZmC5B,CAAlD,EAAK,EAAL,E,EYnCiE,CAW/D,CZmBF,CY9BP,EdIO,E,sDe9CM,E,Yb6EsB,E,Ea7ER,G,Eb6E8B,CAAlD,EAAK,EAAL,Ea7EM,E,EAA2C,EbwEzC,G,EAAA,GaxEF,CAAb,E,EACA,E,KAAc,E,Kb4EqB,E,Ea5ErB,G,Eb4E2C,CAAlD,EAAK,EAAL,Ea5EkB,GAAzB,Ef6CO,E,sDevCU,E,YbsEkB,E,EatEJ,G,EbsE0B,CAAlD,EAAK,EAAL,EatEM,E,EAA4C,EbiE1C,G,EAAA,GajEF,CAAb,E,EACA,E,KAAc,E,KbqEqB,E,EarErB,G,EbqE2C,CAAlD,EAAK,EAAL,EarEkB,GAAzB,EfsCO,E,sDehCM,E,Yb+DsB,E,Ea/DR,G,Eb+D8B,CAAlD,EAAK,EAAL,Ea/DM,E,EAA2C,Eb0DzC,G,EAAA,Ga1DF,CAAb,E,EACA,E,KAAc,E,Kb8DqB,E,Ea9DrB,G,Eb8D2C,CAAlD,EAAK,EAAL,Ea9DkB,GAAzB,Ef+BO,E,sDezBU,E,YbwDkB,E,EaxDJ,G,EbwD0B,CAAlD,EAAK,EAAL,EaxDM,E,EAA4C,EbmD1C,G,EAAA,GanDF,CAAb,E,EACA,E,KAAc,E,KbuDqB,E,EavDrB,G,EbuD2C,CAAlD,EAAK,EAAL,EavDkB,GAAzB,EfwBO,E,6DelBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbiDJ,E,EajDI,G,EbiDkB,CAAlD,EAAK,EAAL,EajDkB,E,IAAyB,E,KAAc,E,KbiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EajD6B,G,EbiDP,CAAlD,EAAK,EAAL,EajD2C,EAAzB,IAAzB,EfkBO,E,6DeZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kb2CR,E,Ea3CQ,G,Eb2Cc,CAAlD,EAAK,EAAL,Ea3CkB,E,IAAkC,E,KAAc,E,Kb2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea3CsC,G,Eb2ChB,CAAlD,EAAK,EAAL,Ea3CgD,EAA9B,IAAzB,EfYO,E,wDgB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdyEG,E,EczEH,G,EdyEyB,CAAlD,EAAK,EAAL,E,EczEO,CAAd,E,EACA,E,KAAc,E,KdwEqB,E,EcxErB,G,EdwE2C,CAAlD,EAAK,EAAL,EcxEgC,EAAS,EAAT,CdmEhC,CcnEP,EhByCO,E,wDgBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdiEG,E,EcjEH,G,EdiEyB,CAAlD,EAAK,EAAL,E,EcjEO,CAAd,E,EACA,E,KAAc,E,KdgEqB,E,EchErB,G,EdgE2C,CAAlD,EAAK,EAAL,EchEgC,EAAU,EAAV,Cd2DhC,Cc3DP,EhBiCO,E,sDgB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KdyDX,E,EczDW,G,EdyDW,CAAlD,EAAK,EAAL,E,EczDqB,CAA5B,E,EACA,E,KAAc,E,KdwDqB,E,EcxDrB,G,EdwD2C,CAAlD,EAAK,EAAL,EcxDkB,E,EAAS,CAAT,CAAzB,EhByBO,E,sDgBnBW,E,KAAc,E,KdkDG,E,EclDH,G,EdkDyB,CAAlD,EAAK,EAAL,EclDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EdiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KcjD0C,EAAV,Cd4ChC,Cc5CP,EhBkBO,E,sDgBZW,E,KAAc,E,Kd2CG,E,Ec3CH,G,Ed2CyB,CAAlD,EAAK,EAAL,Ec3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,Ed0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,Kc1C2C,EAAX,CdqChC,CcrCP,EhBWO,E,sDgBLW,E,YdoCiB,E,EcpCH,G,EdoCyB,CAAlD,EAAK,EAAL,EcpCW,E,GAAJ,CAAd,E,EAC0B,E,Kd8BX,Gc9Bf,E,EACA,E,KAAc,E,KdkCqB,E,EclCrB,G,EdkC2C,CAAlD,EAAK,EAAL,EclCoC,E,EAAO,C,CAAX,CAAvC,EhBGO,E,6DgBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kd2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ec3BI,G,Ed2BkB,CAAlD,EAAK,EAAL,Ec3BkB,E,EAA0B,CAA1B,CAAzB,EhBJO,E,6DgBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcpBI,G,EdoBkB,CAAlD,EAAK,EAAL,EcpBkB,E,EAA2B,CAA3B,CAAzB,EhBXO,E,sDgBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdaG,E,EcbH,G,EdayB,CAAlD,EAAK,EAAL,EcbO,EAAd,E,EACA,E,KAAc,E,KdYqB,E,EcZrB,G,EdY2C,CAAlD,EAAK,EAAL,EcZkB,E,EAAS,CAAT,CAAzB,EhBnBO,E,sDgByBW,E,KAAc,E,KdMG,E,EcNH,G,EdMyB,CAAlD,EAAK,EAAL,EcNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EdAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EcAmC,CAAzB,CAAzB,EhB1BO,E,sDgBgCW,E,KAAc,E,KdDG,E,EcCH,G,EdDyB,CAAlD,EAAK,EAAL,EcCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EdPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EcOoC,CAA1B,CAAzB,EhBjCO,E,sDgBuCW,E,YdRiB,E,EcQH,G,EdRyB,CAAlD,EAAK,EAAL,EcQW,E,GAAJ,CAAd,E,EAC4B,E,Kddb,Gccf,E,EACA,E,KAAc,E,KdVqB,E,EcUrB,G,EdV2C,CAAlD,EAAK,EAAL,EcUoC,E,EAAS,C,CAAb,CAAvC,EhBzCO,E,wDgB+CW,E,KAAc,E,KdhBG,E,EcgBH,G,EdhByB,CAAlD,EAAK,EAAL,EcgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KdjBG,E,EciBH,G,EdjByB,CAAlD,EAAK,EAAL,E,EciBO,CAAd,E,EACA,E,KAAc,E,KdlBqB,E,EckBrB,G,EdlB2C,CAAlD,EAAK,EAAL,EckBgC,EAAS,EAAT,CdvBhC,CcuBP,EhBjDO,E,wDgBuDW,E,KAAc,E,KdxBG,E,EcwBH,G,EdxByB,CAAlD,EAAK,EAAL,EcwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KdzBG,E,EcyBH,G,EdzByB,CAAlD,EAAK,EAAL,E,EcyBO,CAAd,E,EACA,E,KAAc,E,Kd1BqB,E,Ec0BrB,G,Ed1B2C,CAAlD,EAAK,EAAL,Ec0BgC,EAAU,EAAV,Cd/BhC,Cc+BP,EhBzDO,E,sDgB+DW,E,KAAc,E,KdhCG,E,EcgCH,G,EdhCyB,CAAlD,EAAK,EAAL,EcgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KdjCd,E,EciCc,G,EdjCQ,CAAlD,EAAK,EAAL,E,EciCwB,CAA/B,E,EACA,E,KAAc,E,KdlCqB,E,EckCrB,G,EdlC2C,CAAlD,EAAK,EAAL,EckCoC,E,EAAY,C,CAAhB,CAAvC,EhBjEO,E,6DgBuEW,E,KAAc,E,KdxCG,E,EcwCH,G,EdxCyB,CAAlD,EAAK,EAAL,EcwCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdzCJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcyCI,G,EdzCkB,CAAlD,EAAK,EAAL,EcyCkB,E,EAA0B,CAA1B,CAAzB,EhBxEO,E,6DgB8EW,E,KAAc,E,Kd/CG,E,Ec+CH,G,Ed/CyB,CAAlD,EAAK,EAAL,Ec+CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdhDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcgDI,G,EdhDkB,CAAlD,EAAK,EAAL,EcgDkB,E,EAA2B,CAA3B,CAAzB,EhB/EO,E,6DgBqFW,E,KAAc,E,KdtDG,E,EcsDH,G,EdtDyB,CAAlD,EAAK,EAAL,EcsDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,KdvDR,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcuDQ,G,EdvDc,CAAlD,EAAK,EAAL,EcuDkB,E,EAA+B,CAA/B,CAAzB,EhBtFO,E,mDV8HkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cACnD,E,GAAiB,E,KAAjB,CAA+B,EAAzC,G,2DQ6DY,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,E,IAAf,G,EACO,E,kEmB/OO,E,QAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,2DnBiPO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,EAAQ,GAAR,CAAf,G,EACI,E,iBAAA,EAAmB,EAAnB,CAAJ,E,EACE,E,iBAAU,EAAK,E,KAAS,EAAT,CAAf,I,EAEA,E,iBAAW,EAAK,E,KAAS,EAAT,CAAhB,I,EAEK,E,kEmBtPO,E,QAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DnBwPO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,EAAK,EAAI,GAAJ,CAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,EAAK,EAAI,GAAJ,CAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEmBrQO,E,QAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DnBuQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,E,EAAK,C,IAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,E,EAAK,C,IAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEmBpRO,E,QAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EfkDjB,GelDG,G,OACD,E,KAAV,E,+DAKO,E,KAAa,E,YAAa,E,KAAc,E,WfiDnB,E,EejDmB,G,EfiDG,CAAlD,EAAK,EAAL,EejDiC,EAAyB,G,CAA9B,CAArB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAc,E,KAAc,E,Wf2CrB,E,Ee3CqB,G,Ef2CC,CAAlD,EAAK,EAAL,Ee3CmC,EAAyB,I,CAA/B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAY,E,KAAc,E,WfqCnB,E,EerCmB,G,EfqCG,CAAlD,EAAK,EAAL,E,EerC6B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAQ,E,KAAc,E,Wf+Bf,E,Ee/Be,G,Ef+BO,CAAlD,EAAK,EAAL,Ee/B6B,EAAtB,G,OACG,E,KAAV,E,6DAKa,E,YfyBe,E,EezBD,G,EfyBuB,CAAlD,EAAK,EAAL,EezBa,E,EAAuC,EfoB5C,G,EAAA,G,CepBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YfkBe,E,EelBD,G,EfkBuB,CAAlD,EAAK,EAAL,EelBa,E,EAAuC,Efa5C,G,EAAA,G,CebC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YfWe,E,EeXD,G,EfWuB,CAAlD,EAAK,EAAL,EeXa,E,EAAuC,EfM5C,G,EAAA,G,CeNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YfIe,E,EeJD,G,EfIuB,CAAlD,EAAK,EAAL,EeJa,E,EAAuC,EfD5C,G,EAAA,G,CeCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EfFjB,GeEG,G,OACD,E,KAAV,E,+DAKa,E,YfHe,E,EeGD,G,EfHuB,CAAlD,EAAK,EAAL,EeGa,E,EAAuC,EfR5C,G,EAAA,G,CeQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EfJQ,E,EeIoB,G,EfJE,CAAlD,EAAK,EAAL,EeIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YfVe,E,EeUD,G,EfVuB,CAAlD,EAAK,EAAL,EeUa,E,EAAuC,Eff5C,G,EAAA,G,CeeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EfXO,E,EeWsB,G,EfXA,CAAlD,EAAK,EAAL,EeWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YfjBe,E,EeiBD,G,EfjBuB,CAAlD,EAAK,EAAL,EeiBa,E,EAAuC,EftB5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OACK,E,QAAf,E,EACgB,EAAI,EAAJ,C,EACU,EAA2B,EAAY,EAAZ,CAA3B,CAAR,G,IAAkE,E,SAAlE,EAA+D,E,EAAlE,E,GAAA,G,KACJ,EAAY,EAAY,EAAZ,CAAZ,CAAuC,EAAhD,GAES,EAAwB,EAA2B,EADxC,EAHK,E,GAAF,E,WAOlB,E,8CRsHG,E,KAOmC,G,EANnC,EAMwC,G,EAAA,G,aAArB,G,wD2B7JI,E,KAAN,E,EAAY,EAA5B,G,KACT,GAAJ,E,OACS,EAAP,E,yEAfO,E,YACA,E,YACA,E,YACA,E,UACO,E,sCAehB,E,KAAmB,E,gCAEX,E,mBAOJ,E,KAA2B,E,OpB3NhB,G,QoBkOX,E,KAAa,E,KAAc,E,OpB7NI,E,EoB6NJ,G,EpB7N0B,CAAlD,EAAK,EAAL,EoB6NU,E,QAIb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,KACb,E,KAAkB,E,KAAJ,GAAe,EAAf,C,IAAyB,EAAJ,G,EAArB,E,EAAqB,GAAtB,C,QAab,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAAa,E,KAAc,E,OpBhPI,E,EoBgPJ,G,EpBhP0B,CAAlD,EAAK,EAAL,EoBgPU,E,QAab,E,KAAa,E,KAAc,E,OpB7PI,E,EoB6PJ,G,EpB7P0B,CAAlD,EAAK,EAAL,EoB6PU,E,KACb,E,KAAa,E,KAAc,E,OpB9PI,E,EoB8PJ,G,EpB9P0B,CAAlD,EAAK,EAAL,EoB8PU,E,KACb,E,KAA2B,E,OpBpQhB,G,KoBqQX,E,KAA2B,E,OpBrQhB,G,QoBwQX,E,KAAa,E,KAAc,E,OpBnQI,E,EoBmQJ,G,EpBnQ0B,CAAlD,EAAK,EAAL,EoBmQU,E,KACb,E,KAAa,E,KAAc,E,OpBpQI,E,EoBoQJ,G,EpBpQ0B,CAAlD,EAAK,EAAL,EoBoQU,E,KACb,E,KAAa,E,KAAc,E,OpBrQI,E,EoBqQJ,G,EpBrQ0B,CAAlD,EAAK,EAAL,EoBqQU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBxNhB,G,QoB4NX,E,KAA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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/0a78010a7801?v=0.6.4 **/\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT = 12;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/24ee0024ee00?v=0.6.4 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const pageIdx = u32(currentAddress >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n const relAddress = currentAddress % PAGE_SIZE;\n const page = this.pages.get(pageIdx);\n const spaceInPage = PAGE_SIZE - relAddress;\n\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** https://graypaper.fluffylabs.dev/#/9a08063/2cc5022cc502?v=0.6.6 */\nexport function decodeSpi(data: Uint8Array): Program {\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const _heapPages = decoder.u16();\n const _stackSize = decoder.u24();\n\n const _roMem = decoder.bytes(roLength);\n const _rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n return deblob(code);\n}\n\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { RUN } from \"./instructions-exe\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, JumpTable, Program, ProgramCounter, decodeArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { InitialChunk, InitialPage, buildMemory } from \"./api-generic\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { VmInput, VmOutput, getAssembly, runVm } from \"./api-generic\";\nimport { deblob, decodeSpi, extractCodeAndMetadata, liftBytes } from \"./program\";\n\nexport * from \"./api\";\nexport { runVm, getAssembly } from \"./api-generic\";\nexport { wrapAsProgram } from \"./program-build\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n let program = liftBytes(input);\n let output = \"\";\n\n if (withMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(program);\n program = data.code;\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += data.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n if (kind === InputKind.Generic) {\n const p = deblob(program);\n return output + getAssembly(p);\n }\n\n if (kind === InputKind.SPI) {\n const p = decodeSpi(program);\n return output + getAssembly(p);\n }\n\n return `Unknown kind: ${kind}`;\n}\n\nexport function runProgram(input: u8[], registers: u64[], kind: InputKind): VmOutput {\n if (kind === InputKind.Generic) {\n const vmInput = new VmInput();\n vmInput.registers = registers;\n vmInput.gas = 10_000;\n vmInput.program = input;\n\n const output = runVm(vmInput, true);\n console.log(`Finished with status: ${output.status}`);\n return output;\n }\n\n if (kind === InputKind.SPI) {\n throw new Error(\"SPI running not supported yet\");\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { Program, deblob, decodeArguments, liftBytes, resolveArguments } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n registers: u64[] = new Array(NO_OF_REGISTERS).fill(0);\n pc: u32 = 0;\n gas: i64 = 0;\n program: u8[] = [];\n pageMap: InitialPage[] = [];\n memory: InitialChunk[] = [];\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const p = deblob(liftBytes(input.program));\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < registers.length; r++) {\n registers[r] = input.registers[r];\n }\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, input.pageMap, input.memory);\n\n const int = new Interpreter(p, registers, memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = p.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n return this.gas < 0;\n }\n}\n","import { Arguments, REQUIRED_BYTES, nibbles } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/dist/release.wat b/dist/release.wat deleted file mode 100644 index 4de45a6..0000000 --- a/dist/release.wat +++ /dev/null @@ -1,36780 +0,0 @@ -(module - (type $0 (func (param i32 i32 i32) (result i32))) - (type $1 (func (param i32 i32) (result i32))) - (type $2 (func (param i32) (result i32))) - (type $3 (func (result i32))) - (type $4 (func (param i32))) - (type $5 (func (param i32 i32))) - (type $6 (func (param i32 i32 i32))) - (type $7 (func (param i32 i32 i32 i32) (result i32))) - (type $8 (func)) - (type $9 (func (param i32 i32 i32 i32))) - (type $10 (func (param i32 i32 i64))) - (type $11 (func (param i32 i64) (result i32))) - (type $12 (func (param i64 i32 i32) (result i32))) - (type $13 (func (param i64) (result i32))) - (type $14 (func (param i32 i32 i32 i32 i64))) - (type $15 (func (param i32 i64 i32 i32))) - (type $16 (func (param i32 i64 i32))) - (type $17 (func (param i32 i64))) - (type $18 (func (param i32) (result i64))) - (type $19 (func (param i32 i32) (result i64))) - (type $20 (func (param i32 i32 i64) (result i32))) - (type $21 (func (result i64))) - (type $22 (func (param i64))) - (type $23 (func (param i64 i32) (result i32))) - (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) - (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) - (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) - (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) - (global $~argumentsLength (mut i32) (i32.const 0)) - (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) - (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) - (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) - (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) - (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) - (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) - (global $assembly/api/interpreter (mut i32) (i32.const 0)) - (global $assembly/index/InputKind.Generic i32 (i32.const 0)) - (global $assembly/index/InputKind.SPI i32 (i32.const 1)) - (global $assembly/index/HasMetadata.Yes i32 (i32.const 0)) - (global $assembly/index/HasMetadata.No i32 (i32.const 1)) - (global $~lib/rt/__rtti_base i32 (i32.const 21056)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 54068)) - (memory $0 1) - (data $0 (i32.const 1036) "L") - (data $0.1 (i32.const 1048) "\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03") - (data $1 (i32.const 1116) ",") - (data $1.1 (i32.const 1128) "\04\00\00\00\10\00\00\00 \04\00\00 \04\00\004\00\00\00\r") - (data $2 (i32.const 1164) "L") - (data $2.1 (i32.const 1176) "\01\00\00\004") - (data $2.2 (i32.const 1192) "\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02") - (data $3 (i32.const 1244) ",") - (data $3.1 (i32.const 1256) "\04\00\00\00\10\00\00\00\a0\04\00\00\a0\04\00\004\00\00\00\r") - (data $4 (i32.const 1292) "<") - (data $4.1 (i32.const 1304) "\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e") - (data $5 (i32.const 1356) "<") - (data $5.1 (i32.const 1368) "\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s") - (data $8 (i32.const 1484) "<") - (data $8.1 (i32.const 1496) "\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e") - (data $9 (i32.const 1548) ",") - (data $9.1 (i32.const 1560) "\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s") - (data $11 (i32.const 1628) "<") - (data $11.1 (i32.const 1640) "\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s") - (data $12 (i32.const 1692) "\1c") - (data $12.1 (i32.const 1704) "\08\00\00\00\08\00\00\00\01") - (data $13 (i32.const 1724) "<") - (data $13.1 (i32.const 1736) "\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s") - (data $14 (i32.const 1788) "\1c") - (data $14.1 (i32.const 1800) "\08\00\00\00\08\00\00\00\02") - (data $15 (i32.const 1820) "\1c") - (data $15.1 (i32.const 1832) "\08\00\00\00\08\00\00\00\03") - (data $16 (i32.const 1852) "\1c") - (data $16.1 (i32.const 1864) "\08\00\00\00\08\00\00\00\04") - (data $17 (i32.const 1884) "\1c") - (data $17.1 (i32.const 1896) "\08\00\00\00\08\00\00\00\05") - (data $18 (i32.const 1916) "\1c") - (data $18.1 (i32.const 1928) "\08\00\00\00\08\00\00\00\06") - (data $19 (i32.const 1948) "\1c") - (data $19.1 (i32.const 1960) "\08\00\00\00\08\00\00\00\07") - (data $20 (i32.const 1980) "\1c") - (data $20.1 (i32.const 1992) "\08\00\00\00\08\00\00\00\08") - (data $21 (i32.const 2012) "\1c") - (data $21.1 (i32.const 2024) "\08\00\00\00\08\00\00\00\t") - (data $22 (i32.const 2044) "\1c") - (data $22.1 (i32.const 2056) "\08\00\00\00\08\00\00\00\n") - (data $23 (i32.const 2076) "\1c") - (data $23.1 (i32.const 2088) "\08\00\00\00\08\00\00\00\0b") - (data $24 (i32.const 2108) "\1c") - (data $24.1 (i32.const 2120) "\08\00\00\00\08\00\00\00\0c") - (data $25 (i32.const 2140) "\1c") - (data $25.1 (i32.const 2152) "\08\00\00\00\08\00\00\00\r") - (data $26 (i32.const 2172) "L") - (data $26.1 (i32.const 2184) "\01\00\00\004\00\00\00\b0\06\00\00\10\07\00\000\07\00\00P\07\00\00p\07\00\00\90\07\00\00\b0\07\00\00\d0\07\00\00\f0\07\00\00\10\08\00\000\08\00\00P\08\00\00p\08") - (data $27 (i32.const 2252) ",") - (data $27.1 (i32.const 2264) "\07\00\00\00\10\00\00\00\90\08\00\00\90\08\00\004\00\00\00\r") - (data $28 (i32.const 2300) ",") - (data $28.1 (i32.const 2312) "\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D") - (data $29 (i32.const 2348) "\1c") - (data $29.1 (i32.const 2360) "\02\00\00\00\08\00\00\00S\00B\00R\00K") - (data $30 (i32.const 2380) "\1c") - (data $30.1 (i32.const 2392) "\02\00\00\00\08\00\00\00T\00R\00A\00P") - (data $31 (i32.const 2412) ",") - (data $31.1 (i32.const 2424) "\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H") - (data $32 (i32.const 2460) "\1c") - (data $32.1 (i32.const 2472) "\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I") - (data $33 (i32.const 2492) ",") - (data $33.1 (i32.const 2504) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004") - (data $34 (i32.const 2540) ",") - (data $34.1 (i32.const 2552) "\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008") - (data $35 (i32.const 2588) ",") - (data $35.1 (i32.const 2600) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006") - (data $36 (i32.const 2636) ",") - (data $36.1 (i32.const 2648) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002") - (data $37 (i32.const 2684) ",") - (data $37.1 (i32.const 2696) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004") - (data $38 (i32.const 2732) "\1c") - (data $38.1 (i32.const 2744) "\02\00\00\00\08\00\00\00J\00U\00M\00P") - (data $39 (i32.const 2764) ",") - (data $39.1 (i32.const 2776) "\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D") - (data $40 (i32.const 2812) ",") - (data $40.1 (i32.const 2824) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M") - (data $41 (i32.const 2860) ",") - (data $41.1 (i32.const 2872) "\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008") - (data $42 (i32.const 2908) ",") - (data $42.1 (i32.const 2920) "\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008") - (data $43 (i32.const 2956) ",") - (data $43.1 (i32.const 2968) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006") - (data $44 (i32.const 3004) ",") - (data $44.1 (i32.const 3016) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006") - (data $45 (i32.const 3052) ",") - (data $45.1 (i32.const 3064) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002") - (data $46 (i32.const 3100) ",") - (data $46.1 (i32.const 3112) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002") - (data $47 (i32.const 3148) ",") - (data $47.1 (i32.const 3160) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004") - (data $48 (i32.const 3196) ",") - (data $48.1 (i32.const 3208) "\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008") - (data $49 (i32.const 3244) ",") - (data $49.1 (i32.const 3256) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006") - (data $50 (i32.const 3292) ",") - (data $50.1 (i32.const 3304) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002") - (data $51 (i32.const 3340) ",") - (data $51.1 (i32.const 3352) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004") - (data $52 (i32.const 3388) "<") - (data $52.1 (i32.const 3400) "\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008") - (data $53 (i32.const 3452) "<") - (data $53.1 (i32.const 3464) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006") - (data $54 (i32.const 3516) "<") - (data $54.1 (i32.const 3528) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002") - (data $55 (i32.const 3580) "<") - (data $55.1 (i32.const 3592) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004") - (data $56 (i32.const 3644) ",") - (data $56.1 (i32.const 3656) "\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P") - (data $57 (i32.const 3692) ",") - (data $57.1 (i32.const 3704) "\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M") - (data $58 (i32.const 3740) ",") - (data $58.1 (i32.const 3752) "\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M") - (data $59 (i32.const 3788) "<") - (data $59.1 (i32.const 3800) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M") - (data $60 (i32.const 3852) "<") - (data $60.1 (i32.const 3864) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M") - (data $61 (i32.const 3916) "<") - (data $61.1 (i32.const 3928) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M") - (data $62 (i32.const 3980) "<") - (data $62.1 (i32.const 3992) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M") - (data $63 (i32.const 4044) "<") - (data $63.1 (i32.const 4056) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M") - (data $64 (i32.const 4108) "<") - (data $64.1 (i32.const 4120) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M") - (data $65 (i32.const 4172) "<") - (data $65.1 (i32.const 4184) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M") - (data $66 (i32.const 4236) "<") - (data $66.1 (i32.const 4248) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M") - (data $67 (i32.const 4300) ",") - (data $67.1 (i32.const 4312) "\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G") - (data $68 (i32.const 4348) "<") - (data $68.1 (i32.const 4360) "\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004") - (data $69 (i32.const 4412) "<") - (data $69.1 (i32.const 4424) "\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002") - (data $70 (i32.const 4476) "<") - (data $70.1 (i32.const 4488) "\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004") - (data $71 (i32.const 4540) "<") - (data $71.1 (i32.const 4552) "\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002") - (data $72 (i32.const 4604) "<") - (data $72.1 (i32.const 4616) "\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004") - (data $73 (i32.const 4668) "<") - (data $73.1 (i32.const 4680) "\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002") - (data $74 (i32.const 4732) ",") - (data $74.1 (i32.const 4744) "\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008") - (data $75 (i32.const 4780) ",") - (data $75.1 (i32.const 4792) "\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006") - (data $76 (i32.const 4828) ",") - (data $76.1 (i32.const 4840) "\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006") - (data $77 (i32.const 4876) ",") - (data $77.1 (i32.const 4888) "\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S") - (data $78 (i32.const 4924) ",") - (data $78.1 (i32.const 4936) "\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008") - (data $79 (i32.const 4972) ",") - (data $79.1 (i32.const 4984) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006") - (data $80 (i32.const 5020) ",") - (data $80.1 (i32.const 5032) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002") - (data $81 (i32.const 5068) ",") - (data $81.1 (i32.const 5080) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004") - (data $82 (i32.const 5116) ",") - (data $82.1 (i32.const 5128) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008") - (data $83 (i32.const 5164) ",") - (data $83.1 (i32.const 5176) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008") - (data $84 (i32.const 5212) ",") - (data $84.1 (i32.const 5224) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006") - (data $85 (i32.const 5260) ",") - (data $85.1 (i32.const 5272) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006") - (data $86 (i32.const 5308) ",") - (data $86.1 (i32.const 5320) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002") - (data $87 (i32.const 5356) ",") - (data $87.1 (i32.const 5368) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002") - (data $88 (i32.const 5404) ",") - (data $88.1 (i32.const 5416) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004") - (data $89 (i32.const 5452) ",") - (data $89.1 (i32.const 5464) "\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002") - (data $90 (i32.const 5500) ",") - (data $90.1 (i32.const 5512) "\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M") - (data $91 (i32.const 5548) ",") - (data $91.1 (i32.const 5560) "\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M") - (data $92 (i32.const 5596) "\1c") - (data $92.1 (i32.const 5608) "\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M") - (data $93 (i32.const 5628) ",") - (data $93.1 (i32.const 5640) "\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002") - (data $94 (i32.const 5676) ",") - (data $94.1 (i32.const 5688) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M") - (data $95 (i32.const 5724) ",") - (data $95.1 (i32.const 5736) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M") - (data $96 (i32.const 5772) ",") - (data $96.1 (i32.const 5784) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002") - (data $97 (i32.const 5820) ",") - (data $97.1 (i32.const 5832) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002") - (data $98 (i32.const 5868) ",") - (data $98.1 (i32.const 5880) "\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002") - (data $99 (i32.const 5916) ",") - (data $99.1 (i32.const 5928) "\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002") - (data $100 (i32.const 5964) ",") - (data $100.1 (i32.const 5976) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M") - (data $101 (i32.const 6012) ",") - (data $101.1 (i32.const 6024) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M") - (data $102 (i32.const 6060) "<") - (data $102.1 (i32.const 6072) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") - (data $103 (i32.const 6124) "<") - (data $103.1 (i32.const 6136) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") - (data $104 (i32.const 6188) "<") - (data $104.1 (i32.const 6200) "\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") - (data $105 (i32.const 6252) ",") - (data $105.1 (i32.const 6264) "\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M") - (data $106 (i32.const 6300) ",") - (data $106.1 (i32.const 6312) "\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M") - (data $107 (i32.const 6348) ",") - (data $107.1 (i32.const 6360) "\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004") - (data $108 (i32.const 6396) ",") - (data $108.1 (i32.const 6408) "\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004") - (data $109 (i32.const 6444) ",") - (data $109.1 (i32.const 6456) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004") - (data $110 (i32.const 6492) ",") - (data $110.1 (i32.const 6504) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004") - (data $111 (i32.const 6540) ",") - (data $111.1 (i32.const 6552) "\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004") - (data $112 (i32.const 6588) ",") - (data $112.1 (i32.const 6600) "\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004") - (data $113 (i32.const 6636) "<") - (data $113.1 (i32.const 6648) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") - (data $114 (i32.const 6700) "<") - (data $114.1 (i32.const 6712) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") - (data $115 (i32.const 6764) "<") - (data $115.1 (i32.const 6776) "\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") - (data $116 (i32.const 6828) ",") - (data $116.1 (i32.const 6840) "\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M") - (data $117 (i32.const 6876) "<") - (data $117.1 (i32.const 6888) "\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T") - (data $118 (i32.const 6940) ",") - (data $118.1 (i32.const 6952) "\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M") - (data $119 (i32.const 6988) "<") - (data $119.1 (i32.const 7000) "\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T") - (data $120 (i32.const 7052) ",") - (data $120.1 (i32.const 7064) "\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q") - (data $121 (i32.const 7100) ",") - (data $121.1 (i32.const 7112) "\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E") - (data $122 (i32.const 7148) ",") - (data $122.1 (i32.const 7160) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U") - (data $123 (i32.const 7196) ",") - (data $123.1 (i32.const 7208) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S") - (data $124 (i32.const 7244) ",") - (data $124.1 (i32.const 7256) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U") - (data $125 (i32.const 7292) ",") - (data $125.1 (i32.const 7304) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S") - (data $126 (i32.const 7340) "<") - (data $126.1 (i32.const 7352) "\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D") - (data $127 (i32.const 7404) "\1c") - (data $127.1 (i32.const 7416) "\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002") - (data $128 (i32.const 7436) "\1c") - (data $128.1 (i32.const 7448) "\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002") - (data $129 (i32.const 7468) "\1c") - (data $129.1 (i32.const 7480) "\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002") - (data $130 (i32.const 7500) ",") - (data $130.1 (i32.const 7512) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002") - (data $131 (i32.const 7548) ",") - (data $131.1 (i32.const 7560) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002") - (data $132 (i32.const 7596) ",") - (data $132.1 (i32.const 7608) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002") - (data $133 (i32.const 7644) ",") - (data $133.1 (i32.const 7656) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002") - (data $134 (i32.const 7692) ",") - (data $134.1 (i32.const 7704) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002") - (data $135 (i32.const 7740) ",") - (data $135.1 (i32.const 7752) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002") - (data $136 (i32.const 7788) ",") - (data $136.1 (i32.const 7800) "\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002") - (data $137 (i32.const 7836) "\1c") - (data $137.1 (i32.const 7848) "\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004") - (data $138 (i32.const 7868) "\1c") - (data $138.1 (i32.const 7880) "\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004") - (data $139 (i32.const 7900) "\1c") - (data $139.1 (i32.const 7912) "\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004") - (data $140 (i32.const 7932) ",") - (data $140.1 (i32.const 7944) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004") - (data $141 (i32.const 7980) ",") - (data $141.1 (i32.const 7992) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004") - (data $142 (i32.const 8028) ",") - (data $142.1 (i32.const 8040) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004") - (data $143 (i32.const 8076) ",") - (data $143.1 (i32.const 8088) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004") - (data $144 (i32.const 8124) ",") - (data $144.1 (i32.const 8136) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004") - (data $145 (i32.const 8172) ",") - (data $145.1 (i32.const 8184) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004") - (data $146 (i32.const 8220) ",") - (data $146.1 (i32.const 8232) "\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004") - (data $147 (i32.const 8268) "\1c") - (data $147.1 (i32.const 8280) "\02\00\00\00\06\00\00\00A\00N\00D") - (data $148 (i32.const 8300) "\1c") - (data $148.1 (i32.const 8312) "\02\00\00\00\06\00\00\00X\00O\00R") - (data $149 (i32.const 8332) "\1c") - (data $149.1 (i32.const 8344) "\02\00\00\00\04\00\00\00O\00R") - (data $150 (i32.const 8364) ",") - (data $150.1 (i32.const 8376) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S") - (data $151 (i32.const 8412) ",") - (data $151.1 (i32.const 8424) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U") - (data $152 (i32.const 8460) ",") - (data $152.1 (i32.const 8472) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U") - (data $153 (i32.const 8508) ",") - (data $153.1 (i32.const 8520) "\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U") - (data $154 (i32.const 8556) ",") - (data $154.1 (i32.const 8568) "\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S") - (data $155 (i32.const 8604) ",") - (data $155.1 (i32.const 8616) "\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z") - (data $156 (i32.const 8652) ",") - (data $156.1 (i32.const 8664) "\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z") - (data $157 (i32.const 8700) ",") - (data $157.1 (i32.const 8712) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004") - (data $158 (i32.const 8748) ",") - (data $158.1 (i32.const 8760) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002") - (data $159 (i32.const 8796) ",") - (data $159.1 (i32.const 8808) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004") - (data $160 (i32.const 8844) ",") - (data $160.1 (i32.const 8856) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002") - (data $161 (i32.const 8892) ",") - (data $161.1 (i32.const 8904) "\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V") - (data $162 (i32.const 8940) "\1c") - (data $162.1 (i32.const 8952) "\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V") - (data $163 (i32.const 8972) "\1c") - (data $163.1 (i32.const 8984) "\02\00\00\00\08\00\00\00X\00N\00O\00R") - (data $164 (i32.const 9004) "\1c") - (data $164.1 (i32.const 9016) "\02\00\00\00\06\00\00\00M\00A\00X") - (data $165 (i32.const 9036) "\1c") - (data $165.1 (i32.const 9048) "\02\00\00\00\n\00\00\00M\00A\00X\00_\00U") - (data $166 (i32.const 9068) "\1c") - (data $166.1 (i32.const 9080) "\02\00\00\00\06\00\00\00M\00I\00N") - (data $167 (i32.const 9100) "\1c") - (data $167.1 (i32.const 9112) "\02\00\00\00\n\00\00\00M\00I\00N\00_\00U") - (data $168 (i32.const 9132) ",") - (data $168.1 (i32.const 9144) "\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s") - (data $169 (i32.const 9180) ",") - (data $169.1 (i32.const 9192) "\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h") - (data $170 (i32.const 9228) "<") - (data $170.1 (i32.const 9240) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s") - (data $171 (i32.const 9292) "<") - (data $171.1 (i32.const 9304) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s") - (data $172 (i32.const 9356) "\1c") - (data $172.1 (i32.const 9368) "\14\00\00\00\08\00\00\00\0e") - (data $173 (i32.const 9388) "\1c") - (data $173.1 (i32.const 9400) "\14\00\00\00\08\00\00\00\0f") - (data $174 (i32.const 9420) "\1c") - (data $174.1 (i32.const 9432) "\14\00\00\00\08\00\00\00\10") - (data $175 (i32.const 9452) "\1c") - (data $175.1 (i32.const 9464) "\14\00\00\00\08\00\00\00\11") - (data $176 (i32.const 9484) "\1c") - (data $176.1 (i32.const 9496) "\14\00\00\00\08\00\00\00\12") - (data $177 (i32.const 9516) "\1c") - (data $177.1 (i32.const 9528) "\14\00\00\00\08\00\00\00\13") - (data $178 (i32.const 9548) "\1c") - (data $178.1 (i32.const 9560) "\14\00\00\00\08\00\00\00\14") - (data $179 (i32.const 9580) "\1c") - (data $179.1 (i32.const 9592) "\14\00\00\00\08\00\00\00\15") - (data $180 (i32.const 9612) "\1c") - (data $180.1 (i32.const 9624) "\14\00\00\00\08\00\00\00\16") - (data $181 (i32.const 9644) "\1c") - (data $181.1 (i32.const 9656) "\14\00\00\00\08\00\00\00\17") - (data $182 (i32.const 9676) "\1c") - (data $182.1 (i32.const 9688) "\14\00\00\00\08\00\00\00\18") - (data $183 (i32.const 9708) "\1c") - (data $183.1 (i32.const 9720) "\14\00\00\00\08\00\00\00\19") - (data $184 (i32.const 9740) "\1c") - (data $184.1 (i32.const 9752) "\14\00\00\00\08\00\00\00\1a") - (data $185 (i32.const 9772) "\1c") - (data $185.1 (i32.const 9784) "\14\00\00\00\08\00\00\00\1b") - (data $186 (i32.const 9804) "\1c") - (data $186.1 (i32.const 9816) "\14\00\00\00\08\00\00\00\1c") - (data $187 (i32.const 9836) "\1c") - (data $187.1 (i32.const 9848) "\14\00\00\00\08\00\00\00\1d") - (data $188 (i32.const 9868) "\1c") - (data $188.1 (i32.const 9880) "\14\00\00\00\08\00\00\00\1e") - (data $189 (i32.const 9900) "\1c") - (data $189.1 (i32.const 9912) "\14\00\00\00\08\00\00\00\1f") - (data $190 (i32.const 9932) "\1c") - (data $190.1 (i32.const 9944) "\14\00\00\00\08\00\00\00 ") - (data $191 (i32.const 9964) "\1c") - (data $191.1 (i32.const 9976) "\14\00\00\00\08\00\00\00!") - (data $192 (i32.const 9996) "\1c") - (data $192.1 (i32.const 10008) "\14\00\00\00\08\00\00\00\"") - (data $193 (i32.const 10028) "\1c") - (data $193.1 (i32.const 10040) "\14\00\00\00\08\00\00\00#") - (data $194 (i32.const 10060) "\1c") - (data $194.1 (i32.const 10072) "\14\00\00\00\08\00\00\00$") - (data $195 (i32.const 10092) "\1c") - (data $195.1 (i32.const 10104) "\14\00\00\00\08\00\00\00%") - (data $196 (i32.const 10124) "\1c") - (data $196.1 (i32.const 10136) "\14\00\00\00\08\00\00\00&") - (data $197 (i32.const 10156) "\1c") - (data $197.1 (i32.const 10168) "\14\00\00\00\08\00\00\00\'") - (data $198 (i32.const 10188) "\1c") - (data $198.1 (i32.const 10200) "\14\00\00\00\08\00\00\00(") - (data $199 (i32.const 10220) "\1c") - (data $199.1 (i32.const 10232) "\14\00\00\00\08\00\00\00)") - (data $200 (i32.const 10252) "\1c") - (data $200.1 (i32.const 10264) "\14\00\00\00\08\00\00\00*") - (data $201 (i32.const 10284) "\1c") - (data $201.1 (i32.const 10296) "\14\00\00\00\08\00\00\00+") - (data $202 (i32.const 10316) "\1c") - (data $202.1 (i32.const 10328) "\14\00\00\00\08\00\00\00,") - (data $203 (i32.const 10348) "\1c") - (data $203.1 (i32.const 10360) "\14\00\00\00\08\00\00\00-") - (data $204 (i32.const 10380) "<") - (data $204.1 (i32.const 10392) "\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t") - (data $205 (i32.const 10444) ",") - (data $205.1 (i32.const 10456) "\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s") - (data $206 (i32.const 10492) "|") - (data $206.1 (i32.const 10504) "\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)") - (data $207 (i32.const 10620) "L") - (data $207.1 (i32.const 10632) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s") - (data $208 (i32.const 10700) "\1c") - (data $208.1 (i32.const 10712) "\14\00\00\00\08\00\00\00.") - (data $209 (i32.const 10732) "\1c") - (data $209.1 (i32.const 10744) "\14\00\00\00\08\00\00\00/") - (data $210 (i32.const 10764) "\1c") - (data $210.1 (i32.const 10776) "\14\00\00\00\08\00\00\000") - (data $211 (i32.const 10796) "\1c") - (data $211.1 (i32.const 10808) "\14\00\00\00\08\00\00\001") - (data $212 (i32.const 10828) "\1c") - (data $212.1 (i32.const 10840) "\14\00\00\00\08\00\00\002") - (data $213 (i32.const 10860) "\1c") - (data $213.1 (i32.const 10872) "\14\00\00\00\08\00\00\003") - (data $214 (i32.const 10892) "\1c") - (data $214.1 (i32.const 10904) "\14\00\00\00\08\00\00\004") - (data $215 (i32.const 10924) "\1c") - (data $215.1 (i32.const 10936) "\14\00\00\00\08\00\00\005") - (data $216 (i32.const 10956) "\1c") - (data $216.1 (i32.const 10968) "\14\00\00\00\08\00\00\006") - (data $217 (i32.const 10988) "\1c") - (data $217.1 (i32.const 11000) "\14\00\00\00\08\00\00\007") - (data $218 (i32.const 11020) "\1c") - (data $218.1 (i32.const 11032) "\14\00\00\00\08\00\00\008") - (data $219 (i32.const 11052) "\1c") - (data $219.1 (i32.const 11064) "\14\00\00\00\08\00\00\009") - (data $220 (i32.const 11084) "\1c") - (data $220.1 (i32.const 11096) "\14\00\00\00\08\00\00\00:") - (data $221 (i32.const 11116) "\1c") - (data $221.1 (i32.const 11128) "\14\00\00\00\08\00\00\00;") - (data $222 (i32.const 11148) "\1c") - (data $222.1 (i32.const 11160) "\14\00\00\00\08\00\00\00<") - (data $223 (i32.const 11180) "\1c") - (data $223.1 (i32.const 11192) "\14\00\00\00\08\00\00\00=") - (data $224 (i32.const 11212) "\1c") - (data $224.1 (i32.const 11224) "\14\00\00\00\08\00\00\00>") - (data $225 (i32.const 11244) "\1c") - (data $225.1 (i32.const 11256) "\14\00\00\00\08\00\00\00?") - (data $226 (i32.const 11276) "\1c") - (data $226.1 (i32.const 11288) "\14\00\00\00\08\00\00\00@") - (data $227 (i32.const 11308) "\1c") - (data $227.1 (i32.const 11320) "\14\00\00\00\08\00\00\00A") - (data $228 (i32.const 11340) "\1c") - (data $228.1 (i32.const 11352) "\14\00\00\00\08\00\00\00B") - (data $229 (i32.const 11372) "\1c") - (data $229.1 (i32.const 11384) "\14\00\00\00\08\00\00\00C") - (data $230 (i32.const 11404) "\1c") - (data $230.1 (i32.const 11416) "\14\00\00\00\08\00\00\00D") - (data $231 (i32.const 11436) "\1c") - (data $231.1 (i32.const 11448) "\14\00\00\00\08\00\00\00E") - (data $232 (i32.const 11468) "\1c") - (data $232.1 (i32.const 11480) "\14\00\00\00\08\00\00\00F") - (data $233 (i32.const 11500) "\1c") - (data $233.1 (i32.const 11512) "\14\00\00\00\08\00\00\00G") - (data $234 (i32.const 11532) "\1c") - (data $234.1 (i32.const 11544) "\14\00\00\00\08\00\00\00H") - (data $235 (i32.const 11564) "\1c") - (data $235.1 (i32.const 11576) "\14\00\00\00\08\00\00\00I") - (data $236 (i32.const 11596) "\1c") - (data $236.1 (i32.const 11608) "\14\00\00\00\08\00\00\00J") - (data $237 (i32.const 11628) "\1c") - (data $237.1 (i32.const 11640) "\14\00\00\00\08\00\00\00K") - (data $238 (i32.const 11660) "\1c") - (data $238.1 (i32.const 11672) "\14\00\00\00\08\00\00\00L") - (data $239 (i32.const 11692) "\1c") - (data $239.1 (i32.const 11704) "\14\00\00\00\08\00\00\00M") - (data $240 (i32.const 11724) "\1c") - (data $240.1 (i32.const 11736) "\14\00\00\00\08\00\00\00N") - (data $241 (i32.const 11756) "\1c") - (data $241.1 (i32.const 11768) "\14\00\00\00\08\00\00\00O") - (data $242 (i32.const 11788) "\1c") - (data $242.1 (i32.const 11800) "\14\00\00\00\08\00\00\00P") - (data $243 (i32.const 11820) "\1c") - (data $243.1 (i32.const 11832) "\14\00\00\00\08\00\00\00Q") - (data $244 (i32.const 11852) "\1c") - (data $244.1 (i32.const 11864) "\14\00\00\00\08\00\00\00R") - (data $245 (i32.const 11884) "\1c") - (data $245.1 (i32.const 11896) "\14\00\00\00\08\00\00\00S") - (data $246 (i32.const 11916) "\1c") - (data $246.1 (i32.const 11928) "\14\00\00\00\08\00\00\00T") - (data $247 (i32.const 11948) "\1c") - (data $247.1 (i32.const 11960) "\14\00\00\00\08\00\00\00U") - (data $248 (i32.const 11980) "\1c") - (data $248.1 (i32.const 11992) "\14\00\00\00\08\00\00\00V") - (data $249 (i32.const 12012) "\1c") - (data $249.1 (i32.const 12024) "\14\00\00\00\08\00\00\00W") - (data $250 (i32.const 12044) "\1c") - (data $250.1 (i32.const 12056) "\14\00\00\00\08\00\00\00X") - (data $251 (i32.const 12076) "\1c") - (data $251.1 (i32.const 12088) "\14\00\00\00\08\00\00\00Y") - (data $252 (i32.const 12108) "\1c") - (data $252.1 (i32.const 12120) "\14\00\00\00\08\00\00\00Z") - (data $253 (i32.const 12140) "\1c") - (data $253.1 (i32.const 12152) "\14\00\00\00\08\00\00\00[") - (data $254 (i32.const 12172) "\1c") - (data $254.1 (i32.const 12184) "\14\00\00\00\08\00\00\00\\") - (data $255 (i32.const 12204) "\1c") - (data $255.1 (i32.const 12216) "\14\00\00\00\08\00\00\00]") - (data $256 (i32.const 12236) "\1c") - (data $256.1 (i32.const 12248) "\14\00\00\00\08\00\00\00^") - (data $257 (i32.const 12268) "\1c") - (data $257.1 (i32.const 12280) "\14\00\00\00\08\00\00\00_") - (data $258 (i32.const 12300) "\1c") - (data $258.1 (i32.const 12312) "\14\00\00\00\08\00\00\00`") - (data $259 (i32.const 12332) "\1c") - (data $259.1 (i32.const 12344) "\14\00\00\00\08\00\00\00a") - (data $260 (i32.const 12364) "\1c") - (data $260.1 (i32.const 12376) "\14\00\00\00\08\00\00\00b") - (data $261 (i32.const 12396) "\1c") - (data $261.1 (i32.const 12408) "\14\00\00\00\08\00\00\00c") - (data $262 (i32.const 12428) "\1c") - (data $262.1 (i32.const 12440) "\14\00\00\00\08\00\00\00d") - (data $263 (i32.const 12460) "\1c") - (data $263.1 (i32.const 12472) "\14\00\00\00\08\00\00\00e") - (data $264 (i32.const 12492) "\1c") - (data $264.1 (i32.const 12504) "\14\00\00\00\08\00\00\00f") - (data $265 (i32.const 12524) "\1c") - (data $265.1 (i32.const 12536) "\14\00\00\00\08\00\00\00g") - (data $266 (i32.const 12556) "\1c") - (data $266.1 (i32.const 12568) "\14\00\00\00\08\00\00\00h") - (data $267 (i32.const 12588) "\1c") - (data $267.1 (i32.const 12600) "\14\00\00\00\08\00\00\00i") - (data $268 (i32.const 12620) "\1c") - (data $268.1 (i32.const 12632) "\14\00\00\00\08\00\00\00j") - (data $269 (i32.const 12652) "\1c") - (data $269.1 (i32.const 12664) "\14\00\00\00\08\00\00\00k") - (data $270 (i32.const 12684) "\1c") - (data $270.1 (i32.const 12696) "\14\00\00\00\08\00\00\00l") - (data $271 (i32.const 12716) "\1c") - (data $271.1 (i32.const 12728) "\14\00\00\00\08\00\00\00m") - (data $272 (i32.const 12748) "\1c") - (data $272.1 (i32.const 12760) "\14\00\00\00\08\00\00\00n") - (data $273 (i32.const 12780) "\1c") - (data $273.1 (i32.const 12792) "\14\00\00\00\08\00\00\00o") - (data $274 (i32.const 12812) "\1c") - (data $274.1 (i32.const 12824) "\14\00\00\00\08\00\00\00p") - (data $275 (i32.const 12844) "\1c") - (data $275.1 (i32.const 12856) "\14\00\00\00\08\00\00\00q") - (data $276 (i32.const 12876) "\1c") - (data $276.1 (i32.const 12888) "\14\00\00\00\08\00\00\00r") - (data $277 (i32.const 12908) "\1c") - (data $277.1 (i32.const 12920) "\14\00\00\00\08\00\00\00s") - (data $278 (i32.const 12940) "\1c") - (data $278.1 (i32.const 12952) "\14\00\00\00\08\00\00\00t") - (data $279 (i32.const 12972) "\1c") - (data $279.1 (i32.const 12984) "\14\00\00\00\08\00\00\00u") - (data $280 (i32.const 13004) "\1c") - (data $280.1 (i32.const 13016) "\14\00\00\00\08\00\00\00v") - (data $281 (i32.const 13036) "\1c") - (data $281.1 (i32.const 13048) "\14\00\00\00\08\00\00\00w") - (data $282 (i32.const 13068) "\1c") - (data $282.1 (i32.const 13080) "\14\00\00\00\08\00\00\00x") - (data $283 (i32.const 13100) "\1c") - (data $283.1 (i32.const 13112) "\14\00\00\00\08\00\00\00y") - (data $284 (i32.const 13132) "\1c") - (data $284.1 (i32.const 13144) "\14\00\00\00\08\00\00\00z") - (data $285 (i32.const 13164) "\1c") - (data $285.1 (i32.const 13176) "\14\00\00\00\08\00\00\00{") - (data $286 (i32.const 13196) "\1c") - (data $286.1 (i32.const 13208) "\14\00\00\00\08\00\00\00|") - (data $287 (i32.const 13228) "\1c") - (data $287.1 (i32.const 13240) "\14\00\00\00\08\00\00\00}") - (data $288 (i32.const 13260) "\1c") - (data $288.1 (i32.const 13272) "\14\00\00\00\08\00\00\00~") - (data $289 (i32.const 13292) "\1c") - (data $289.1 (i32.const 13304) "\14\00\00\00\08\00\00\00\7f") - (data $290 (i32.const 13324) "\1c") - (data $290.1 (i32.const 13336) "\14\00\00\00\08\00\00\00\80") - (data $291 (i32.const 13356) "\1c") - (data $291.1 (i32.const 13368) "\14\00\00\00\08\00\00\00\81") - (data $292 (i32.const 13388) "\1c") - (data $292.1 (i32.const 13400) "\14\00\00\00\08\00\00\00\82") - (data $293 (i32.const 13420) "\1c") - (data $293.1 (i32.const 13432) "\14\00\00\00\08\00\00\00\83") - (data $294 (i32.const 13452) "\1c") - (data $294.1 (i32.const 13464) "\14\00\00\00\08\00\00\00\84") - (data $295 (i32.const 13484) "\1c") - (data $295.1 (i32.const 13496) "\14\00\00\00\08\00\00\00\85") - (data $296 (i32.const 13516) "\1c") - (data $296.1 (i32.const 13528) "\14\00\00\00\08\00\00\00\86") - (data $297 (i32.const 13548) "\1c") - (data $297.1 (i32.const 13560) "\14\00\00\00\08\00\00\00\87") - (data $298 (i32.const 13580) "\1c") - (data $298.1 (i32.const 13592) "\14\00\00\00\08\00\00\00\88") - (data $299 (i32.const 13612) "\1c") - (data $299.1 (i32.const 13624) "\14\00\00\00\08\00\00\00\89") - (data $300 (i32.const 13644) "\1c") - (data $300.1 (i32.const 13656) "\14\00\00\00\08\00\00\00\8a") - (data $301 (i32.const 13676) "\1c") - (data $301.1 (i32.const 13688) "\14\00\00\00\08\00\00\00\8b") - (data $302 (i32.const 13708) "\1c") - (data $302.1 (i32.const 13720) "\14\00\00\00\08\00\00\00\8c") - (data $303 (i32.const 13740) "\1c") - (data $303.1 (i32.const 13752) "\14\00\00\00\08\00\00\00\8d") - (data $304 (i32.const 13772) "\1c") - (data $304.1 (i32.const 13784) "\14\00\00\00\08\00\00\00\8e") - (data $305 (i32.const 13804) "\1c") - (data $305.1 (i32.const 13816) "\14\00\00\00\08\00\00\00\8f") - (data $306 (i32.const 13836) "\1c") - (data $306.1 (i32.const 13848) "\14\00\00\00\08\00\00\00\90") - (data $307 (i32.const 13868) "\1c") - (data $307.1 (i32.const 13880) "\14\00\00\00\08\00\00\00\91") - (data $308 (i32.const 13900) "\1c") - (data $308.1 (i32.const 13912) "\14\00\00\00\08\00\00\00\92") - (data $309 (i32.const 13932) "\1c") - (data $309.1 (i32.const 13944) "\14\00\00\00\08\00\00\00\93") - (data $310 (i32.const 13964) "\1c") - (data $310.1 (i32.const 13976) "\14\00\00\00\08\00\00\00\94") - (data $311 (i32.const 13996) "\1c") - (data $311.1 (i32.const 14008) "\14\00\00\00\08\00\00\00\95") - (data $312 (i32.const 14028) "\1c") - (data $312.1 (i32.const 14040) "\14\00\00\00\08\00\00\00\96") - (data $313 (i32.const 14060) "\1c") - (data $313.1 (i32.const 14072) "\14\00\00\00\08\00\00\00\97") - (data $314 (i32.const 14092) "\1c") - (data $314.1 (i32.const 14104) "\14\00\00\00\08\00\00\00\98") - (data $315 (i32.const 14124) ",") - (data $315.1 (i32.const 14136) "\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y") - (data $316 (i32.const 14172) "\\") - (data $316.1 (i32.const 14184) "\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.") - (data $317 (i32.const 14268) "\1c") - (data $317.1 (i32.const 14280) "\14\00\00\00\08\00\00\00\99") - (data $318 (i32.const 14300) "\ac\03") - (data $318.1 (i32.const 14312) "\01\00\00\00\9c\03\00\00\e06\00\00\007\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 7\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00`(\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c04\00\00\e04\00\00\005\00\00 5\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\e0\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\00(\00\00\80(\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\00`*\00\00\80*\00\00\a0*\00\00@5\00\00`5\00\00\805\00\00\a05\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c05\00\00\e05\00\00\006\00\00 6\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 (\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00\c0&\00\00\e0&\00\00\00\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 0\00\00\d07\00\00\a0$\00\00\c0$\00\00\e0$\00\00\00%\00\00 %\00\00@%\00\00`%\00\00\80%\00\00\a0%\00\00\c0%\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00@6\00\00`6\00\00\806\00\00\a06\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00@+\00\00`+\00\00\80+\00\00\c0,\00\00\a0+\00\00\c0+\00\00\e0+\00\00\e0,\00\00\c01\00\00\e01\00\00\802\00\00\a02\00\00\c02\00\00\00-\00\00\002\00\00 2\00\00\e02\00\00\003\00\00 3\00\00@0\00\00`0\00\00 -\00\00@-\00\00@3\00\00`3\00\00\803\00\00`-\00\00\a03\00\00\c03\00\00\e03\00\00\c00\00\00\e00\00\00\001\00\00 1\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\a0\'\00\00\c0\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00@(\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\80-\00\00\a0-\00\00\c0-\00\00\e0-\00\00\00.\00\00 .\00\00@.\00\00\004\00\00 4\00\00@4\00\00`.\00\00\80.\00\00\a0.\00\00\c0.\00\00\e0.\00\00\00/\00\00 /\00\00`4\00\00\804\00\00\a04\00\00\00,\00\00 ,\00\00@,\00\00@/\00\00`/\00\00\80/\00\00@2\00\00`2\00\00\800\00\00\a00\00\00@1\00\00`1\00\00\801\00\00\a01\00\00`,\00\00\80,\00\00\a0,\00\00\a0/\00\00\c0/\00\00\e0/\00\00\000") - (data $319 (i32.const 15244) ",") - (data $319.1 (i32.const 15256) "\1a\00\00\00\10\00\00\00\f07\00\00\f07\00\00\9c\03\00\00\e7") - (data $320 (i32.const 15292) "\1c") - (data $320.1 (i32.const 15304) "\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80") - (data $321 (i32.const 15324) ",") - (data $321.1 (i32.const 15336) "\1b\00\00\00\10\00\00\00\d0;\00\00\d0;\00\00\08\00\00\00\08") - (data $322 (i32.const 15372) "\1c") - (data $322.1 (i32.const 15384) "\1c\00\00\00\08\00\00\00\9a") - (data $323 (i32.const 15404) "\1c") - (data $323.1 (i32.const 15416) "\02") - (data $324 (i32.const 15436) "L") - (data $324.1 (i32.const 15448) "\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 ") - (data $325 (i32.const 15516) ",") - (data $325.1 (i32.const 15528) "\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 ") - (data $326 (i32.const 15564) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00`<\00\00\00\00\00\00\b0<") - (data $327 (i32.const 15612) "|") - (data $327.1 (i32.const 15624) "\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006") - (data $328 (i32.const 15740) "<") - (data $328.1 (i32.const 15752) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s") - (data $329 (i32.const 15804) "\1c") - (data $329.1 (i32.const 15816) "\02\00\00\00\02\00\00\000") - (data $330 (i32.const 15836) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009") - (data $331 (i32.const 16236) "\1c\04") - (data $331.1 (i32.const 16248) "\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f") - (data $332 (i32.const 17292) "\\") - (data $332.1 (i32.const 17304) "\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z") - (data $333 (i32.const 17388) "<") - (data $333.1 (i32.const 17400) "\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s") - (data $334 (i32.const 17452) "l") - (data $334.1 (i32.const 17464) "\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 ") - (data $335 (i32.const 17564) ",") - (data $335.1 (i32.const 17576) "\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 ") - (data $336 (i32.const 17612) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00@D\00\00\00\00\00\00\b0D") - (data $337 (i32.const 17660) ",") - (data $337.1 (i32.const 17672) "\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n") - (data $338 (i32.const 17708) "\1c") - (data $338.1 (i32.const 17720) "\02\00\00\00\04\00\00\000\00x") - (data $339 (i32.const 17740) "\1c") - (data $339.1 (i32.const 17752) ")\00\00\00\08\00\00\00\9b") - (data $340 (i32.const 17772) "\1c") - (data $340.1 (i32.const 17784) "\02\00\00\00\04\00\00\00\n\00\n") - (data $341 (i32.const 17804) "|") - (data $341.1 (i32.const 17816) "\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y") - (data $342 (i32.const 17932) "L") - (data $342.1 (i32.const 17944) "\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>") - (data $343 (i32.const 18012) "l") - (data $343.1 (i32.const 18024) "\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!") - (data $344 (i32.const 18124) "L") - (data $344.1 (i32.const 18136) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00g\00e\00n\00e\00r\00i\00c\00.\00t\00s") - (data $345 (i32.const 18204) "\1c") - (data $345.1 (i32.const 18216) "\02\00\00\00\02\00\00\00\n") - (data $346 (i32.const 18236) "\1c") - (data $346.1 (i32.const 18248) "\02\00\00\00\04\00\00\00:\00 ") - (data $347 (i32.const 18268) "\1c") - (data $347.1 (i32.const 18280) "\02\00\00\00\02\00\00\00(") - (data $348 (i32.const 18300) "\1c") - (data $348.1 (i32.const 18312) "\02\00\00\00\02\00\00\00)") - (data $349 (i32.const 18332) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pG\00\00\00\00\00\00\90G") - (data $350 (i32.const 18364) "\1c") - (data $350.1 (i32.const 18376) "\02\00\00\00\02\00\00\00 ") - (data $351 (i32.const 18396) "\1c") - (data $351.1 (i32.const 18408) "\02\00\00\00\04\00\00\00,\00 ") - (data $352 (i32.const 18428) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00\d0G\00\00\00\00\00\00\f0G") - (data $353 (i32.const 18460) "|") - (data $353.1 (i32.const 18472) "\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 ") - (data $354 (i32.const 18588) ",") - (data $354.1 (i32.const 18600) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 ") - (data $355 (i32.const 18636) "\1c") - (data $355.1 (i32.const 18648) "\01") - (data $356 (i32.const 18668) "\1c") - (data $356.1 (i32.const 18680) "\01") - (data $357 (i32.const 18700) "\1c") - (data $357.1 (i32.const 18712) "\01") - (data $358 (i32.const 18732) "\1c") - (data $358.1 (i32.const 18744) "\01") - (data $359 (i32.const 18764) "\\") - (data $359.1 (i32.const 18776) "\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 ") - (data $360 (i32.const 18860) "<") - (data $360.1 (i32.const 18872) "\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s") - (data $361 (i32.const 18924) "l") - (data $361.1 (i32.const 18936) "\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!") - (data $362 (i32.const 19036) ",") - (data $362.1 (i32.const 19048) "\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 ") - (data $363 (i32.const 19084) ",") - (data $363.1 (i32.const 19096) "\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)") - (data $364 (i32.const 19132) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pJ\00\00\00\00\00\00\a0J") - (data $365 (i32.const 19164) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pJ\00\00\00\00\00\00\a0J") - (data $366 (i32.const 19196) "\1c") - (data $366.1 (i32.const 19208) "5\00\00\00\08\00\00\00\9c") - (data $367 (i32.const 19228) "<") - (data $367.1 (i32.const 19240) "\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 ") - (data $368 (i32.const 19292) "\1c") - (data $368.1 (i32.const 19304) "\02\00\00\00\n\00\00\00P\00C\00 \00=\00 ") - (data $369 (i32.const 19324) ",") - (data $369.1 (i32.const 19336) "\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 ") - (data $370 (i32.const 19372) "\1c") - (data $370.1 (i32.const 19384) "5\00\00\00\08\00\00\00\9d") - (data $371 (i32.const 19404) ",") - (data $371.1 (i32.const 19416) "\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 ") - (data $372 (i32.const 19452) "\1c") - (data $372.1 (i32.const 19464) "\02\00\00\00\04\00\00\00 \00(") - (data $373 (i32.const 19484) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\14\00\00\00\e0K\00\00\00\00\00\00\10L\00\00\00\00\00\00\90G") - (data $374 (i32.const 19532) "L") - (data $374.1 (i32.const 19544) "\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 ") - (data $375 (i32.const 19612) "<") - (data $375.1 (i32.const 19624) "\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s") - (data $376 (i32.const 19676) ",") - (data $376.1 (i32.const 19688) "\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 ") - (data $377 (i32.const 19724) "\1c") - (data $377.1 (i32.const 19736) "\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x") - (data $378 (i32.const 19756) "\1c") - (data $378.1 (i32.const 19768) "\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 ") - (data $379 (i32.const 19788) "\1c") - (data $379.1 (i32.const 19800) "\02\00\00\00\08\00\00\00,\00\n\00 \00 ") - (data $380 (i32.const 19820) "|\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00`\00\00\00\f0L\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00@M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00`M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00`M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M") - (data $381 (i32.const 19948) ",") - (data $381.1 (i32.const 19960) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t") - (data $382 (i32.const 19996) "L") - (data $382.1 (i32.const 20008) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s") - (data $383 (i32.const 20076) "\1c") - (data $383.1 (i32.const 20088) "\01") - (data $384 (i32.const 20108) "\1c") - (data $384.1 (i32.const 20120) "\01") - (data $385 (i32.const 20140) "\1c") - (data $385.1 (i32.const 20152) "\01") - (data $386 (i32.const 20172) "\1c") - (data $386.1 (i32.const 20184) "\01") - (data $387 (i32.const 20204) "L") - (data $387.1 (i32.const 20216) "\02\00\00\00:\00\00\00S\00P\00I\00 \00r\00u\00n\00n\00i\00n\00g\00 \00n\00o\00t\00 \00s\00u\00p\00p\00o\00r\00t\00e\00d\00 \00y\00e\00t") - (data $388 (i32.const 20284) "<") - (data $388.1 (i32.const 20296) "\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00d\00e\00x\00.\00t\00s") - (data $389 (i32.const 20348) "L") - (data $389.1 (i32.const 20360) "\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s") - (data $390 (i32.const 20428) "\1c") - (data $390.1 (i32.const 20440) "\01") - (data $391 (i32.const 20460) "<") - (data $391.1 (i32.const 20472) "\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s") - (data $392 (i32.const 20524) "L") - (data $392.1 (i32.const 20536) "\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 ") - (data $393 (i32.const 20604) "\\") - (data $393.1 (i32.const 20616) "\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 ") - (data $394 (i32.const 20700) ",") - (data $394.1 (i32.const 20712) "\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 ") - (data $395 (i32.const 20748) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00\90P\00\00\00\00\00\00\f0P") - (data $396 (i32.const 20796) "<") - (data $396.1 (i32.const 20808) "\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00.\00t\00s") - (data $397 (i32.const 20860) "\1c") - (data $397.1 (i32.const 20872) "\01") - (data $398 (i32.const 20892) "\1c") - (data $398.1 (i32.const 20904) "\01") - (data $399 (i32.const 20924) "<") - (data $399.1 (i32.const 20936) "\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d") - (data $400 (i32.const 20988) "<") - (data $400.1 (i32.const 21000) "\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d") - (data $401 (i32.const 21056) "<\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 ") - (data $401.1 (i32.const 21116) "$\02") - (data $401.2 (i32.const 21128) "\02A\00\00\10A\02\00 ") - (data $401.3 (i32.const 21152) "d") - (data $401.4 (i32.const 21164) "\02A\00\00B") - (data $401.5 (i32.const 21188) "$\01") - (data $401.6 (i32.const 21200) "$\t\00\00 ") - (data $401.7 (i32.const 21216) "\04A\00\00 \00\00\00\00\00\00\00\02\01\00\00\02\02") - (data $401.8 (i32.const 21244) "\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A") - (data $401.9 (i32.const 21280) " \00\00\00 \00\00\00\02A\00\00d") - (table $0 158 158 funcref) - (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $assembly/index/disassemble~anonymous|0 $assembly/api-generic/runVm~anonymous|0 $assembly/api-generic/runVm~anonymous|0) - (export "InputKind.Generic" (global $assembly/index/InputKind.Generic)) - (export "InputKind.SPI" (global $assembly/index/InputKind.SPI)) - (export "HasMetadata.Yes" (global $assembly/index/HasMetadata.Yes)) - (export "HasMetadata.No" (global $assembly/index/HasMetadata.No)) - (export "nextStep" (func $assembly/api/nextStep)) - (export "nSteps" (func $assembly/api/nSteps)) - (export "getProgramCounter" (func $assembly/api/getProgramCounter)) - (export "setNextProgramCounter" (func $assembly/api/setNextProgramCounter)) - (export "getStatus" (func $assembly/api/getStatus)) - (export "getExitArg" (func $assembly/api/getExitArg)) - (export "getGasLeft" (func $assembly/api/getGasLeft)) - (export "setGasLeft" (func $assembly/api/setGasLeft)) - (export "getRegisters" (func $assembly/api/getRegisters)) - (export "getPageDump" (func $assembly/api/getPageDump)) - (export "__new" (func $~lib/rt/itcms/__new)) - (export "__pin" (func $~lib/rt/itcms/__pin)) - (export "__unpin" (func $~lib/rt/itcms/__unpin)) - (export "__collect" (func $~lib/rt/itcms/__collect)) - (export "__rtti_base" (global $~lib/rt/__rtti_base)) - (export "memory" (memory $0)) - (export "__setArgumentsLength" (func $~setArgumentsLength)) - (export "disassemble" (func $export:assembly/index/disassemble)) - (export "runProgram" (func $export:assembly/index/runProgram)) - (export "runVm" (func $export:assembly/api-generic/runVm@varargs)) - (export "getAssembly" (func $export:assembly/api-generic/getAssembly)) - (export "wrapAsProgram" (func $export:assembly/program-build/wrapAsProgram)) - (export "resetGeneric" (func $export:assembly/api/resetGeneric)) - (export "resetGenericWithMemory" (func $export:assembly/api/resetGenericWithMemory)) - (export "setRegisters" (func $export:assembly/api/setRegisters)) - (export "setMemory" (func $export:assembly/api/setMemory)) - (start $~start) - (func $~lib/rt/itcms/visitRoots - (local $0 i32) - (local $1 i32) - i32.const 1504 - call $~lib/rt/itcms/__visit - i32.const 9200 - call $~lib/rt/itcms/__visit - i32.const 14144 - call $~lib/rt/itcms/__visit - i32.const 17824 - call $~lib/rt/itcms/__visit - i32.const 10400 - call $~lib/rt/itcms/__visit - i32.const 1312 - call $~lib/rt/itcms/__visit - i32.const 20944 - call $~lib/rt/itcms/__visit - i32.const 21008 - call $~lib/rt/itcms/__visit - i32.const 16256 - call $~lib/rt/itcms/__visit - i32.const 17312 - call $~lib/rt/itcms/__visit - global.get $assembly/api/interpreter - local.tee $0 - if - local.get $0 - call $~lib/rt/itcms/__visit - end - i32.const 1136 - call $~lib/rt/itcms/__visit - i32.const 1264 - call $~lib/rt/itcms/__visit - i32.const 2272 - call $~lib/rt/itcms/__visit - global.get $assembly/instructions/INSTRUCTIONS - local.tee $0 - if - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $0 - if - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $0 - if - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_PAGE - local.tee $0 - if - local.get $0 - call $~lib/rt/itcms/__visit - end - i32.const 15344 - call $~lib/rt/itcms/__visit - i32.const 15264 - call $~lib/rt/itcms/__visit - global.get $~lib/rt/itcms/pinSpace - local.tee $1 - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - loop $while-continue|0 - local.get $0 - local.get $1 - i32.ne - if - local.get $0 - i32.load offset=4 - i32.const 3 - i32.and - i32.const 3 - i32.ne - if - i32.const 0 - i32.const 1376 - i32.const 160 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.const 20 - i32.add - call $~lib/rt/__visit_members - local.get $0 - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - br $while-continue|0 - end - end - ) - (func $~lib/rt/itcms/Object#unlink (param $0 i32) - (local $1 i32) - local.get $0 - i32.load offset=4 - i32.const -4 - i32.and - local.tee $1 - i32.eqz - if - local.get $0 - i32.load offset=8 - i32.eqz - local.get $0 - i32.const 54068 - i32.lt_u - i32.and - i32.eqz - if - i32.const 0 - i32.const 1376 - i32.const 128 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - return - end - local.get $0 - i32.load offset=8 - local.tee $0 - i32.eqz - if - i32.const 0 - i32.const 1376 - i32.const 132 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $1 - local.get $0 - i32.store offset=8 - local.get $0 - local.get $1 - local.get $0 - i32.load offset=4 - i32.const 3 - i32.and - i32.or - i32.store offset=4 - ) - (func $~lib/rt/itcms/Object#makeGray (param $0 i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - local.get $0 - global.get $~lib/rt/itcms/iter - i32.eq - if - local.get $0 - i32.load offset=8 - local.tee $1 - i32.eqz - if - i32.const 0 - i32.const 1376 - i32.const 148 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.get $1 - global.set $~lib/rt/itcms/iter - end - local.get $0 - call $~lib/rt/itcms/Object#unlink - global.get $~lib/rt/itcms/toSpace - local.set $1 - local.get $0 - i32.load offset=12 - local.tee $2 - i32.const 2 - i32.le_u - if (result i32) - i32.const 1 - else - local.get $2 - i32.const 21056 - i32.load - i32.gt_u - if - i32.const 1504 - i32.const 1568 - i32.const 21 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $2 - i32.const 2 - i32.shl - i32.const 21060 - i32.add - i32.load - i32.const 32 - i32.and - end - local.set $3 - local.get $1 - i32.load offset=8 - local.set $2 - local.get $0 - global.get $~lib/rt/itcms/white - i32.eqz - i32.const 2 - local.get $3 - select - local.get $1 - i32.or - i32.store offset=4 - local.get $0 - local.get $2 - i32.store offset=8 - local.get $2 - local.get $0 - local.get $2 - i32.load offset=4 - i32.const 3 - i32.and - i32.or - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=8 - ) - (func $~lib/rt/itcms/__visit (param $0 i32) - local.get $0 - i32.eqz - if - return - end - global.get $~lib/rt/itcms/white - local.get $0 - i32.const 20 - i32.sub - local.tee $0 - i32.load offset=4 - i32.const 3 - i32.and - i32.eq - if - local.get $0 - call $~lib/rt/itcms/Object#makeGray - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.add - global.set $~lib/rt/itcms/visitCount - end - ) - (func $~lib/rt/tlsf/removeBlock (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - local.get $1 - i32.load - local.tee $3 - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 268 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.const -4 - i32.and - local.tee $3 - i32.const 12 - i32.lt_u - if - i32.const 0 - i32.const 1648 - i32.const 270 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.const 256 - i32.lt_u - if (result i32) - local.get $3 - i32.const 4 - i32.shr_u - else - i32.const 31 - i32.const 1073741820 - local.get $3 - local.get $3 - i32.const 1073741820 - i32.ge_u - select - local.tee $3 - i32.clz - i32.sub - local.tee $4 - i32.const 7 - i32.sub - local.set $2 - local.get $3 - local.get $4 - i32.const 4 - i32.sub - i32.shr_u - i32.const 16 - i32.xor - end - local.tee $3 - i32.const 16 - i32.lt_u - local.get $2 - i32.const 23 - i32.lt_u - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 284 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.load offset=8 - local.set $5 - local.get $1 - i32.load offset=4 - local.tee $4 - if - local.get $4 - local.get $5 - i32.store offset=8 - end - local.get $5 - if - local.get $5 - local.get $4 - i32.store offset=4 - end - local.get $1 - local.get $0 - local.get $2 - i32.const 4 - i32.shl - local.get $3 - i32.add - i32.const 2 - i32.shl - i32.add - local.tee $1 - i32.load offset=96 - i32.eq - if - local.get $1 - local.get $5 - i32.store offset=96 - local.get $5 - i32.eqz - if - local.get $0 - local.get $2 - i32.const 2 - i32.shl - i32.add - local.tee $1 - i32.load offset=4 - i32.const -2 - local.get $3 - i32.rotl - i32.and - local.set $3 - local.get $1 - local.get $3 - i32.store offset=4 - local.get $3 - i32.eqz - if - local.get $0 - local.get $0 - i32.load - i32.const -2 - local.get $2 - i32.rotl - i32.and - i32.store - end - end - end - ) - (func $~lib/rt/tlsf/insertBlock (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - local.get $1 - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 201 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.load - local.tee $3 - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 203 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.const 4 - i32.add - local.get $1 - i32.load - i32.const -4 - i32.and - i32.add - local.tee $4 - i32.load - local.tee $2 - i32.const 1 - i32.and - if - local.get $0 - local.get $4 - call $~lib/rt/tlsf/removeBlock - local.get $1 - local.get $3 - i32.const 4 - i32.add - local.get $2 - i32.const -4 - i32.and - i32.add - local.tee $3 - i32.store - local.get $1 - i32.const 4 - i32.add - local.get $1 - i32.load - i32.const -4 - i32.and - i32.add - local.tee $4 - i32.load - local.set $2 - end - local.get $3 - i32.const 2 - i32.and - if - local.get $1 - i32.const 4 - i32.sub - i32.load - local.tee $1 - i32.load - local.tee $6 - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 221 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - call $~lib/rt/tlsf/removeBlock - local.get $1 - local.get $6 - i32.const 4 - i32.add - local.get $3 - i32.const -4 - i32.and - i32.add - local.tee $3 - i32.store - end - local.get $4 - local.get $2 - i32.const 2 - i32.or - i32.store - local.get $3 - i32.const -4 - i32.and - local.tee $2 - i32.const 12 - i32.lt_u - if - i32.const 0 - i32.const 1648 - i32.const 233 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $4 - local.get $1 - i32.const 4 - i32.add - local.get $2 - i32.add - i32.ne - if - i32.const 0 - i32.const 1648 - i32.const 234 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $4 - i32.const 4 - i32.sub - local.get $1 - i32.store - local.get $2 - i32.const 256 - i32.lt_u - if (result i32) - local.get $2 - i32.const 4 - i32.shr_u - else - i32.const 31 - i32.const 1073741820 - local.get $2 - local.get $2 - i32.const 1073741820 - i32.ge_u - select - local.tee $2 - i32.clz - i32.sub - local.tee $3 - i32.const 7 - i32.sub - local.set $5 - local.get $2 - local.get $3 - i32.const 4 - i32.sub - i32.shr_u - i32.const 16 - i32.xor - end - local.tee $2 - i32.const 16 - i32.lt_u - local.get $5 - i32.const 23 - i32.lt_u - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 251 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $5 - i32.const 4 - i32.shl - local.get $2 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - local.set $3 - local.get $1 - i32.const 0 - i32.store offset=4 - local.get $1 - local.get $3 - i32.store offset=8 - local.get $3 - if - local.get $3 - local.get $1 - i32.store offset=4 - end - local.get $0 - local.get $5 - i32.const 4 - i32.shl - local.get $2 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $1 - i32.store offset=96 - local.get $0 - local.get $0 - i32.load - i32.const 1 - local.get $5 - i32.shl - i32.or - i32.store - local.get $0 - local.get $5 - i32.const 2 - i32.shl - i32.add - local.tee $0 - local.get $0 - i32.load offset=4 - i32.const 1 - local.get $2 - i32.shl - i32.or - i32.store offset=4 - ) - (func $~lib/rt/tlsf/addMemory (param $0 i32) (param $1 i32) (param $2 i64) - (local $3 i32) - (local $4 i32) - (local $5 i32) - local.get $2 - local.get $1 - i64.extend_i32_u - i64.lt_u - if - i32.const 0 - i32.const 1648 - i32.const 382 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.const 19 - i32.add - i32.const -16 - i32.and - i32.const 4 - i32.sub - local.set $1 - local.get $0 - i32.load offset=1568 - local.tee $3 - if - local.get $3 - i32.const 4 - i32.add - local.get $1 - i32.gt_u - if - i32.const 0 - i32.const 1648 - i32.const 389 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $3 - local.get $1 - i32.const 16 - i32.sub - local.tee $5 - i32.eq - if - local.get $3 - i32.load - local.set $4 - local.get $5 - local.set $1 - end - else - local.get $0 - i32.const 1572 - i32.add - local.get $1 - i32.gt_u - if - i32.const 0 - i32.const 1648 - i32.const 402 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - end - local.get $2 - i32.wrap_i64 - i32.const -16 - i32.and - local.get $1 - i32.sub - local.tee $3 - i32.const 20 - i32.lt_u - if - return - end - local.get $1 - local.get $4 - i32.const 2 - i32.and - local.get $3 - i32.const 8 - i32.sub - local.tee $3 - i32.const 1 - i32.or - i32.or - i32.store - local.get $1 - i32.const 0 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=8 - local.get $1 - i32.const 4 - i32.add - local.get $3 - i32.add - local.tee $3 - i32.const 2 - i32.store - local.get $0 - local.get $3 - i32.store offset=1568 - local.get $0 - local.get $1 - call $~lib/rt/tlsf/insertBlock - ) - (func $~lib/rt/tlsf/initialize - (local $0 i32) - (local $1 i32) - memory.size - local.tee $1 - i32.const 0 - i32.le_s - if (result i32) - i32.const 1 - local.get $1 - i32.sub - memory.grow - i32.const 0 - i32.lt_s - else - i32.const 0 - end - if - unreachable - end - i32.const 54080 - i32.const 0 - i32.store - i32.const 55648 - i32.const 0 - i32.store - loop $for-loop|0 - local.get $0 - i32.const 23 - i32.lt_u - if - local.get $0 - i32.const 2 - i32.shl - i32.const 54080 - i32.add - i32.const 0 - i32.store offset=4 - i32.const 0 - local.set $1 - loop $for-loop|1 - local.get $1 - i32.const 16 - i32.lt_u - if - local.get $0 - i32.const 4 - i32.shl - local.get $1 - i32.add - i32.const 2 - i32.shl - i32.const 54080 - i32.add - i32.const 0 - i32.store offset=96 - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|1 - end - end - local.get $0 - i32.const 1 - i32.add - local.set $0 - br $for-loop|0 - end - end - i32.const 54080 - i32.const 55652 - memory.size - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - i32.const 54080 - global.set $~lib/rt/tlsf/ROOT - ) - (func $~lib/rt/itcms/step (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i32) - block $break|0 - block $case2|0 - block $case1|0 - block $case0|0 - global.get $~lib/rt/itcms/state - br_table $case0|0 $case1|0 $case2|0 $break|0 - end - i32.const 1 - global.set $~lib/rt/itcms/state - i32.const 0 - global.set $~lib/rt/itcms/visitCount - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/iter - global.get $~lib/rt/itcms/visitCount - return - end - global.get $~lib/rt/itcms/white - i32.eqz - local.set $1 - global.get $~lib/rt/itcms/iter - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - loop $while-continue|1 - local.get $0 - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $0 - global.set $~lib/rt/itcms/iter - local.get $1 - local.get $0 - i32.load offset=4 - local.tee $2 - i32.const 3 - i32.and - i32.ne - if - local.get $0 - local.get $2 - i32.const -4 - i32.and - local.get $1 - i32.or - i32.store offset=4 - i32.const 0 - global.set $~lib/rt/itcms/visitCount - local.get $0 - i32.const 20 - i32.add - call $~lib/rt/__visit_members - global.get $~lib/rt/itcms/visitCount - return - end - local.get $0 - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - br $while-continue|1 - end - end - i32.const 0 - global.set $~lib/rt/itcms/visitCount - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/iter - i32.load offset=4 - i32.const -4 - i32.and - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.set $0 - loop $while-continue|0 - local.get $0 - i32.const 54068 - i32.lt_u - if - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - local.get $0 - i32.const 4 - i32.add - local.set $0 - br $while-continue|0 - end - end - global.get $~lib/rt/itcms/iter - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - loop $while-continue|2 - local.get $0 - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $1 - local.get $0 - i32.load offset=4 - local.tee $2 - i32.const 3 - i32.and - i32.ne - if - local.get $0 - local.get $2 - i32.const -4 - i32.and - local.get $1 - i32.or - i32.store offset=4 - local.get $0 - i32.const 20 - i32.add - call $~lib/rt/__visit_members - end - local.get $0 - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - br $while-continue|2 - end - end - global.get $~lib/rt/itcms/fromSpace - local.set $0 - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/fromSpace - local.get $0 - global.set $~lib/rt/itcms/toSpace - local.get $1 - global.set $~lib/rt/itcms/white - local.get $0 - i32.load offset=4 - i32.const -4 - i32.and - global.set $~lib/rt/itcms/iter - i32.const 2 - global.set $~lib/rt/itcms/state - end - global.get $~lib/rt/itcms/visitCount - return - end - global.get $~lib/rt/itcms/iter - local.tee $0 - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $0 - i32.load offset=4 - local.tee $1 - i32.const -4 - i32.and - global.set $~lib/rt/itcms/iter - global.get $~lib/rt/itcms/white - i32.eqz - local.get $1 - i32.const 3 - i32.and - i32.ne - if - i32.const 0 - i32.const 1376 - i32.const 229 - i32.const 20 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.const 54068 - i32.lt_u - if - local.get $0 - i32.const 0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=8 - else - global.get $~lib/rt/itcms/total - local.get $0 - i32.load - i32.const -4 - i32.and - i32.const 4 - i32.add - i32.sub - global.set $~lib/rt/itcms/total - local.get $0 - i32.const 4 - i32.add - local.tee $0 - i32.const 54068 - i32.ge_u - if - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $0 - i32.const 4 - i32.sub - local.set $2 - local.get $0 - i32.const 15 - i32.and - i32.const 1 - local.get $0 - select - if (result i32) - i32.const 1 - else - local.get $2 - i32.load - i32.const 1 - i32.and - end - if - i32.const 0 - i32.const 1648 - i32.const 562 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - local.get $2 - local.get $2 - i32.load - i32.const 1 - i32.or - i32.store - local.get $2 - call $~lib/rt/tlsf/insertBlock - end - end - i32.const 10 - return - end - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - i32.store offset=4 - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - i32.store offset=8 - i32.const 0 - global.set $~lib/rt/itcms/state - end - i32.const 0 - ) - (func $~lib/rt/tlsf/searchBlock (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - local.get $1 - i32.const 256 - i32.lt_u - if - local.get $1 - i32.const 4 - i32.shr_u - local.set $1 - else - local.get $1 - i32.const 536870910 - i32.lt_u - if - local.get $1 - i32.const 1 - i32.const 27 - local.get $1 - i32.clz - i32.sub - i32.shl - i32.add - i32.const 1 - i32.sub - local.set $1 - end - local.get $1 - i32.const 31 - local.get $1 - i32.clz - i32.sub - local.tee $2 - i32.const 4 - i32.sub - i32.shr_u - i32.const 16 - i32.xor - local.set $1 - local.get $2 - i32.const 7 - i32.sub - local.set $2 - end - local.get $1 - i32.const 16 - i32.lt_u - local.get $2 - i32.const 23 - i32.lt_u - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 334 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $2 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - i32.const -1 - local.get $1 - i32.shl - i32.and - local.tee $1 - if (result i32) - local.get $0 - local.get $1 - i32.ctz - local.get $2 - i32.const 4 - i32.shl - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - else - local.get $0 - i32.load - i32.const -1 - local.get $2 - i32.const 1 - i32.add - i32.shl - i32.and - local.tee $1 - if (result i32) - local.get $0 - local.get $1 - i32.ctz - local.tee $1 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - local.tee $2 - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 347 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $2 - i32.ctz - local.get $1 - i32.const 4 - i32.shl - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - else - i32.const 0 - end - end - ) - (func $~lib/rt/tlsf/allocateBlock (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - local.get $1 - i32.const 1073741820 - i32.gt_u - if - i32.const 1312 - i32.const 1648 - i32.const 461 - i32.const 29 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 12 - i32.le_u - if (result i32) - i32.const 12 - else - local.get $1 - i32.const 19 - i32.add - i32.const -16 - i32.and - i32.const 4 - i32.sub - end - local.tee $3 - call $~lib/rt/tlsf/searchBlock - local.tee $1 - i32.eqz - if - memory.size - local.tee $1 - local.get $3 - i32.const 256 - i32.ge_u - if (result i32) - local.get $3 - i32.const 536870910 - i32.lt_u - if (result i32) - local.get $3 - i32.const 1 - i32.const 27 - local.get $3 - i32.clz - i32.sub - i32.shl - i32.add - i32.const 1 - i32.sub - else - local.get $3 - end - else - local.get $3 - end - i32.const 4 - local.get $0 - i32.load offset=1568 - local.get $1 - i32.const 16 - i32.shl - i32.const 4 - i32.sub - i32.ne - i32.shl - i32.add - i32.const 65535 - i32.add - i32.const -65536 - i32.and - i32.const 16 - i32.shr_u - local.tee $2 - local.get $1 - local.get $2 - i32.gt_s - select - memory.grow - i32.const 0 - i32.lt_s - if - local.get $2 - memory.grow - i32.const 0 - i32.lt_s - if - unreachable - end - end - local.get $0 - local.get $1 - i32.const 16 - i32.shl - memory.size - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - local.get $0 - local.get $3 - call $~lib/rt/tlsf/searchBlock - local.tee $1 - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 499 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - end - local.get $3 - local.get $1 - i32.load - i32.const -4 - i32.and - i32.gt_u - if - i32.const 0 - i32.const 1648 - i32.const 501 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - call $~lib/rt/tlsf/removeBlock - local.get $1 - i32.load - local.set $4 - local.get $3 - i32.const 4 - i32.add - i32.const 15 - i32.and - if - i32.const 0 - i32.const 1648 - i32.const 361 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $4 - i32.const -4 - i32.and - local.get $3 - i32.sub - local.tee $2 - i32.const 16 - i32.ge_u - if - local.get $1 - local.get $3 - local.get $4 - i32.const 2 - i32.and - i32.or - i32.store - local.get $1 - i32.const 4 - i32.add - local.get $3 - i32.add - local.tee $3 - local.get $2 - i32.const 4 - i32.sub - i32.const 1 - i32.or - i32.store - local.get $0 - local.get $3 - call $~lib/rt/tlsf/insertBlock - else - local.get $1 - local.get $4 - i32.const -2 - i32.and - i32.store - local.get $1 - i32.const 4 - i32.add - local.get $1 - i32.load - i32.const -4 - i32.and - i32.add - local.tee $0 - local.get $0 - i32.load - i32.const -3 - i32.and - i32.store - end - local.get $1 - ) - (func $~lib/rt/itcms/__new (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - local.get $0 - i32.const 1073741804 - i32.ge_u - if - i32.const 1312 - i32.const 1376 - i32.const 261 - i32.const 31 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.ge_u - if - block $__inlined_func$~lib/rt/itcms/interrupt$69 - i32.const 2048 - local.set $2 - loop $do-loop|0 - local.get $2 - call $~lib/rt/itcms/step - i32.sub - local.set $2 - global.get $~lib/rt/itcms/state - i32.eqz - if - global.get $~lib/rt/itcms/total - i64.extend_i32_u - i64.const 200 - i64.mul - i64.const 100 - i64.div_u - i32.wrap_i64 - i32.const 1024 - i32.add - global.set $~lib/rt/itcms/threshold - br $__inlined_func$~lib/rt/itcms/interrupt$69 - end - local.get $2 - i32.const 0 - i32.gt_s - br_if $do-loop|0 - end - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.sub - i32.const 1024 - i32.lt_u - i32.const 10 - i32.shl - i32.add - global.set $~lib/rt/itcms/threshold - end - end - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $0 - i32.const 16 - i32.add - call $~lib/rt/tlsf/allocateBlock - local.tee $2 - local.get $1 - i32.store offset=12 - local.get $2 - local.get $0 - i32.store offset=16 - global.get $~lib/rt/itcms/fromSpace - local.tee $1 - i32.load offset=8 - local.set $3 - local.get $2 - local.get $1 - global.get $~lib/rt/itcms/white - i32.or - i32.store offset=4 - local.get $2 - local.get $3 - i32.store offset=8 - local.get $3 - local.get $2 - local.get $3 - i32.load offset=4 - i32.const 3 - i32.and - i32.or - i32.store offset=4 - local.get $1 - local.get $2 - i32.store offset=8 - global.get $~lib/rt/itcms/total - local.get $2 - i32.load - i32.const -4 - i32.and - i32.const 4 - i32.add - i32.add - global.set $~lib/rt/itcms/total - local.get $2 - i32.const 20 - i32.add - local.tee $1 - i32.const 0 - local.get $0 - memory.fill - local.get $1 - ) - (func $start:assembly/arguments~anonymous|0 (param $0 i32) (param $1 i32) (result i32) - i32.const 0 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - ) - (func $~lib/rt/itcms/__link (param $0 i32) (param $1 i32) (param $2 i32) - (local $3 i32) - local.get $1 - i32.eqz - if - return - end - local.get $0 - i32.eqz - if - i32.const 0 - i32.const 1376 - i32.const 295 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/white - local.get $1 - i32.const 20 - i32.sub - local.tee $1 - i32.load offset=4 - i32.const 3 - i32.and - i32.eq - if - local.get $0 - i32.const 20 - i32.sub - local.tee $0 - i32.load offset=4 - i32.const 3 - i32.and - local.tee $3 - global.get $~lib/rt/itcms/white - i32.eqz - i32.eq - if - local.get $0 - local.get $1 - local.get $2 - select - call $~lib/rt/itcms/Object#makeGray - else - global.get $~lib/rt/itcms/state - i32.const 1 - i32.eq - local.get $3 - i32.const 3 - i32.eq - i32.and - if - local.get $1 - call $~lib/rt/itcms/Object#makeGray - end - end - end - ) - (func $assembly/instructions/instruction (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - i32.const 17 - call $~lib/rt/tlsf/allocateBlock - i32.const 4 - i32.add - local.tee $3 - i32.const 0 - i32.store - local.get $3 - i32.const 0 - i32.store offset=4 - local.get $3 - i64.const 0 - i64.store offset=8 - local.get $3 - i32.const 0 - i32.store8 offset=16 - local.get $3 - local.get $0 - i32.store - local.get $3 - local.get $1 - i32.store offset=4 - local.get $3 - i64.const 1 - i64.store offset=8 - local.get $3 - local.get $2 - i32.store8 offset=16 - local.get $3 - ) - (func $start:assembly/instructions/misc~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $start:assembly/instructions/misc~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - call $assembly/instructions/outcome/OutcomeData#constructor - ) - (func $~lib/util/number/utoa32_dec_lut (param $0 i32) (param $1 i32) (param $2 i32) - (local $3 i32) - loop $while-continue|0 - local.get $1 - i32.const 10000 - i32.ge_u - if - local.get $1 - i32.const 10000 - i32.rem_u - local.set $3 - local.get $1 - i32.const 10000 - i32.div_u - local.set $1 - local.get $0 - local.get $2 - i32.const 4 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $3 - i32.const 100 - i32.div_u - i32.const 2 - i32.shl - i32.const 15836 - i32.add - i64.load32_u - local.get $3 - i32.const 100 - i32.rem_u - i32.const 2 - i32.shl - i32.const 15836 - i32.add - i64.load32_u - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $1 - i32.const 100 - i32.ge_u - if - local.get $0 - local.get $2 - i32.const 2 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $1 - i32.const 100 - i32.rem_u - i32.const 2 - i32.shl - i32.const 15836 - i32.add - i32.load - i32.store - local.get $1 - i32.const 100 - i32.div_u - local.set $1 - end - local.get $1 - i32.const 10 - i32.ge_u - if - local.get $0 - local.get $2 - i32.const 2 - i32.sub - i32.const 1 - i32.shl - i32.add - local.get $1 - i32.const 2 - i32.shl - i32.const 15836 - i32.add - i32.load - i32.store - else - local.get $0 - local.get $2 - i32.const 1 - i32.sub - i32.const 1 - i32.shl - i32.add - local.get $1 - i32.const 48 - i32.add - i32.store16 - end - ) - (func $~lib/util/number/utoa64_any_core (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) - (local $4 i64) - (local $5 i64) - local.get $3 - i64.extend_i32_s - local.set $5 - local.get $3 - local.get $3 - i32.const 1 - i32.sub - i32.and - if - loop $do-loop|1 - local.get $0 - local.get $2 - i32.const 1 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $1 - local.get $1 - local.get $5 - i64.div_u - local.tee $1 - local.get $5 - i64.mul - i64.sub - i32.wrap_i64 - i32.const 1 - i32.shl - i32.const 17312 - i32.add - i32.load16_u - i32.store16 - local.get $1 - i64.const 0 - i64.ne - br_if $do-loop|1 - end - else - local.get $3 - i32.ctz - i32.const 7 - i32.and - i64.extend_i32_s - local.set $4 - local.get $5 - i64.const 1 - i64.sub - local.set $5 - loop $do-loop|0 - local.get $0 - local.get $2 - i32.const 1 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $1 - local.get $5 - i64.and - i32.wrap_i64 - i32.const 1 - i32.shl - i32.const 17312 - i32.add - i32.load16_u - i32.store16 - local.get $1 - local.get $4 - i64.shr_u - local.tee $1 - i64.const 0 - i64.ne - br_if $do-loop|0 - end - end - ) - (func $~lib/number/I32#toString (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $__inlined_func$~lib/util/number/itoa32$98 - local.get $0 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15824 - local.set $0 - br $__inlined_func$~lib/util/number/itoa32$98 - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $0 - i32.sub - local.get $0 - local.get $0 - i32.const 31 - i32.shr_u - i32.const 1 - i32.shl - local.tee $1 - select - local.tee $3 - i32.const 100000 - i32.lt_u - if (result i32) - local.get $3 - i32.const 100 - i32.lt_u - if (result i32) - local.get $3 - i32.const 10 - i32.ge_u - i32.const 1 - i32.add - else - local.get $3 - i32.const 10000 - i32.ge_u - i32.const 3 - i32.add - local.get $3 - i32.const 1000 - i32.ge_u - i32.add - end - else - local.get $3 - i32.const 10000000 - i32.lt_u - if (result i32) - local.get $3 - i32.const 1000000 - i32.ge_u - i32.const 6 - i32.add - else - local.get $3 - i32.const 1000000000 - i32.ge_u - i32.const 8 - i32.add - local.get $3 - i32.const 100000000 - i32.ge_u - i32.add - end - end - local.tee $2 - i32.const 1 - i32.shl - local.get $1 - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - local.get $0 - local.get $1 - i32.add - local.get $3 - local.get $2 - call $~lib/util/number/utoa32_dec_lut - local.get $1 - if - local.get $0 - i32.const 45 - i32.store16 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - end - local.get $0 - ) - (func $~lib/util/number/utoa64_dec_lut (param $0 i32) (param $1 i64) (param $2 i32) - (local $3 i32) - (local $4 i32) - loop $while-continue|0 - local.get $1 - i64.const 100000000 - i64.ge_u - if - local.get $0 - local.get $2 - i32.const 4 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $1 - local.get $1 - i64.const 100000000 - i64.div_u - local.tee $1 - i64.const 100000000 - i64.mul - i64.sub - i32.wrap_i64 - local.tee $3 - i32.const 10000 - i32.rem_u - local.tee $4 - i32.const 100 - i32.div_u - i32.const 2 - i32.shl - i32.const 15836 - i32.add - i64.load32_u - local.get $4 - i32.const 100 - i32.rem_u - i32.const 2 - i32.shl - i32.const 15836 - i32.add - i64.load32_u - i64.const 32 - i64.shl - i64.or - i64.store - local.get $0 - local.get $2 - i32.const 4 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $3 - i32.const 10000 - i32.div_u - local.tee $3 - i32.const 100 - i32.div_u - i32.const 2 - i32.shl - i32.const 15836 - i32.add - i64.load32_u - local.get $3 - i32.const 100 - i32.rem_u - i32.const 2 - i32.shl - i32.const 15836 - i32.add - i64.load32_u - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $0 - local.get $1 - i32.wrap_i64 - local.get $2 - call $~lib/util/number/utoa32_dec_lut - ) - (func $~lib/util/number/itoa_buffered (param $0 i32) (param $1 i64) (result i32) - (local $2 i32) - (local $3 i32) - local.get $0 - local.set $2 - local.get $1 - i64.const 10 - i64.lt_u - if - local.get $0 - local.get $1 - i64.const 48 - i64.or - i64.store16 - i32.const 1 - return - end - local.get $1 - i64.const 4294967295 - i64.le_u - if - local.get $1 - i32.wrap_i64 - local.tee $3 - i32.const 100000 - i32.lt_u - if (result i32) - local.get $3 - i32.const 100 - i32.lt_u - if (result i32) - local.get $3 - i32.const 10 - i32.ge_u - i32.const 1 - i32.add - else - local.get $3 - i32.const 10000 - i32.ge_u - i32.const 3 - i32.add - local.get $3 - i32.const 1000 - i32.ge_u - i32.add - end - else - local.get $3 - i32.const 10000000 - i32.lt_u - if (result i32) - local.get $3 - i32.const 1000000 - i32.ge_u - i32.const 6 - i32.add - else - local.get $3 - i32.const 1000000000 - i32.ge_u - i32.const 8 - i32.add - local.get $3 - i32.const 100000000 - i32.ge_u - i32.add - end - end - local.set $0 - local.get $2 - local.get $3 - local.get $0 - call $~lib/util/number/utoa32_dec_lut - else - local.get $2 - local.get $1 - local.get $1 - i64.const 1000000000000000 - i64.lt_u - if (result i32) - local.get $1 - i64.const 1000000000000 - i64.lt_u - if (result i32) - local.get $1 - i64.const 100000000000 - i64.ge_u - i32.const 10 - i32.add - local.get $1 - i64.const 10000000000 - i64.ge_u - i32.add - else - local.get $1 - i64.const 100000000000000 - i64.ge_u - i32.const 13 - i32.add - local.get $1 - i64.const 10000000000000 - i64.ge_u - i32.add - end - else - local.get $1 - i64.const 100000000000000000 - i64.lt_u - if (result i32) - local.get $1 - i64.const 10000000000000000 - i64.ge_u - i32.const 16 - i32.add - else - local.get $1 - i64.const -8446744073709551616 - i64.ge_u - i32.const 18 - i32.add - local.get $1 - i64.const 1000000000000000000 - i64.ge_u - i32.add - end - end - local.tee $0 - call $~lib/util/number/utoa64_dec_lut - end - local.get $0 - ) - (func $~lib/rt/itcms/__pin (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - local.get $0 - if - local.get $0 - i32.const 20 - i32.sub - local.tee $1 - i32.load offset=4 - i32.const 3 - i32.and - i32.const 3 - i32.eq - if - i32.const 20944 - i32.const 1376 - i32.const 338 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $1 - call $~lib/rt/itcms/Object#unlink - global.get $~lib/rt/itcms/pinSpace - local.tee $3 - i32.load offset=8 - local.set $2 - local.get $1 - local.get $3 - i32.const 3 - i32.or - i32.store offset=4 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $2 - local.get $1 - local.get $2 - i32.load offset=4 - i32.const 3 - i32.and - i32.or - i32.store offset=4 - local.get $3 - local.get $1 - i32.store offset=8 - end - local.get $0 - ) - (func $~lib/rt/itcms/__unpin (param $0 i32) - (local $1 i32) - (local $2 i32) - local.get $0 - i32.eqz - if - return - end - local.get $0 - i32.const 20 - i32.sub - local.tee $1 - i32.load offset=4 - i32.const 3 - i32.and - i32.const 3 - i32.ne - if - i32.const 21008 - i32.const 1376 - i32.const 352 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/state - i32.const 1 - i32.eq - if - local.get $1 - call $~lib/rt/itcms/Object#makeGray - else - local.get $1 - call $~lib/rt/itcms/Object#unlink - global.get $~lib/rt/itcms/fromSpace - local.tee $0 - i32.load offset=8 - local.set $2 - local.get $1 - local.get $0 - global.get $~lib/rt/itcms/white - i32.or - i32.store offset=4 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $2 - local.get $1 - local.get $2 - i32.load offset=4 - i32.const 3 - i32.and - i32.or - i32.store offset=4 - local.get $0 - local.get $1 - i32.store offset=8 - end - ) - (func $~lib/rt/itcms/__collect - global.get $~lib/rt/itcms/state - i32.const 0 - i32.gt_s - if - loop $while-continue|0 - global.get $~lib/rt/itcms/state - if - call $~lib/rt/itcms/step - drop - br $while-continue|0 - end - end - end - call $~lib/rt/itcms/step - drop - loop $while-continue|1 - global.get $~lib/rt/itcms/state - if - call $~lib/rt/itcms/step - drop - br $while-continue|1 - end - end - global.get $~lib/rt/itcms/total - i64.extend_i32_u - i64.const 200 - i64.mul - i64.const 100 - i64.div_u - i32.wrap_i64 - i32.const 1024 - i32.add - global.set $~lib/rt/itcms/threshold - ) - (func $assembly/gas/GasCounter#set@override (param $0 i32) (param $1 i64) - local.get $0 - i32.const 8 - i32.sub - i32.load - i32.const 51 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - unreachable - ) - (func $assembly/gas/GasCounter#sub@override (param $0 i32) (param $1 i64) (result i32) - local.get $0 - i32.const 8 - i32.sub - i32.load - i32.const 51 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i64.load - local.get $1 - i64.sub - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load - i64.const 0 - i64.lt_s - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - unreachable - ) - (func $assembly/gas/GasCounter#get@override (param $0 i32) (result i64) - (local $1 i64) - local.get $0 - i32.const 8 - i32.sub - i32.load - i32.const 51 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - unreachable - ) - (func $assembly/interpreter/Interpreter~visit (param $0 i32) - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - call $~lib/rt/itcms/__visit - ) - (func $~lib/rt/__visit_members (param $0 i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - block $folding-inner9 - block $folding-inner8 - block $folding-inner7 - block $folding-inner6 - block $folding-inner5 - block $folding-inner4 - block $folding-inner3 - block $folding-inner2 - block $folding-inner1 - block $folding-inner0 - block $invalid - block $~lib/staticarray/StaticArray - block $assembly/interpreter/BranchResult - block $assembly/interpreter/DjumpResult - block $assembly/program/ResolvedArguments - block $assembly/gas/GasCounterU64 - block $assembly/api-generic/InitialPage - block $assembly/api-generic/VmInput - block $assembly/api-generic/VmOutput - block $assembly/codec/ValOffset - block $~lib/staticarray/StaticArray<~lib/string/String> - block $assembly/gas/GasCounter - block $~lib/staticarray/StaticArray - block $~lib/staticarray/StaticArray - block $assembly/program/Program - block $assembly/interpreter/Interpreter - block $assembly/memory/Chunks - block $~lib/staticarray/StaticArray - block $assembly/memory/Result - block $assembly/instructions/outcome/OutcomeData - block $"~lib/map/Map" - block $~lib/staticarray/StaticArray - block $assembly/memory/MaybePageFault - block $assembly/arguments/Nibbles - block $assembly/arguments/Args - block $~lib/string/String - block $~lib/arraybuffer/ArrayBuffer - block $~lib/object/Object - local.get $0 - i32.const 8 - i32.sub - i32.load - br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $folding-inner0 $folding-inner1 $folding-inner0 $assembly/arguments/Args $folding-inner2 $folding-inner3 $assembly/arguments/Nibbles $folding-inner1 $assembly/memory/MaybePageFault $folding-inner4 $folding-inner4 $~lib/staticarray/StaticArray $folding-inner5 $folding-inner0 $folding-inner2 $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $folding-inner3 $assembly/memory/Result $folding-inner6 $~lib/staticarray/StaticArray $assembly/memory/Chunks $folding-inner6 $folding-inner2 $folding-inner1 $folding-inner3 $assembly/interpreter/Interpreter $assembly/program/Program $folding-inner0 $~lib/staticarray/StaticArray $folding-inner0 $folding-inner0 $~lib/staticarray/StaticArray $assembly/gas/GasCounter $folding-inner6 $folding-inner0 $~lib/staticarray/StaticArray<~lib/string/String> $assembly/codec/ValOffset $folding-inner3 $folding-inner1 $folding-inner1 $assembly/api-generic/VmOutput $folding-inner4 $folding-inner2 $assembly/api-generic/VmInput $assembly/api-generic/InitialPage $folding-inner2 $folding-inner6 $assembly/gas/GasCounterU64 $folding-inner2 $folding-inner3 $assembly/program/ResolvedArguments $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $folding-inner2 $~lib/staticarray/StaticArray $folding-inner0 $invalid - end - return - end - return - end - return - end - return - end - return - end - return - end - return - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner7 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - local.tee $2 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=16 - i32.const 12 - i32.mul - i32.add - local.set $0 - loop $while-continue|0 - local.get $0 - local.get $1 - i32.gt_u - if - local.get $1 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - local.get $1 - i32.load offset=4 - call $~lib/rt/itcms/__visit - end - local.get $1 - i32.const 12 - i32.add - local.set $1 - br $while-continue|0 - end - end - local.get $2 - call $~lib/rt/itcms/__visit - br $folding-inner9 - end - return - end - local.get $0 - i32.load offset=8 - call $~lib/rt/itcms/__visit - return - end - return - end - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - br $folding-inner5 - end - local.get $0 - call $assembly/interpreter/Interpreter~visit - return - end - local.get $0 - call $assembly/interpreter/Interpreter~visit - return - end - return - end - return - end - return - end - local.get $0 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.add - local.set $1 - loop $while-continue|01 - local.get $0 - local.get $1 - i32.lt_u - if - local.get $0 - i32.load - local.tee $2 - if - local.get $2 - call $~lib/rt/itcms/__visit - end - local.get $0 - i32.const 4 - i32.add - local.set $0 - br $while-continue|01 - end - end - return - end - return - end - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - call $~lib/rt/itcms/__visit - return - end - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=16 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=20 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=24 - call $~lib/rt/itcms/__visit - return - end - return - end - return - end - local.get $0 - i32.load offset=32 - call $~lib/rt/itcms/__visit - return - end - return - end - return - end - return - end - unreachable - end - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - return - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner7 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - br $folding-inner8 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner7 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.const 2 - i32.shl - i32.add - local.set $3 - loop $while-continue|00 - local.get $1 - local.get $3 - i32.lt_u - if - local.get $1 - i32.load - local.tee $2 - if - local.get $2 - call $~lib/rt/itcms/__visit - end - local.get $1 - i32.const 4 - i32.add - local.set $1 - br $while-continue|00 - end - end - br $folding-inner8 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner7 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - br $folding-inner9 - end - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - return - end - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - call $~lib/rt/itcms/__visit - return - end - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~setArgumentsLength (param $0 i32) - local.get $0 - global.set $~argumentsLength - ) - (func $~start - (local $0 i32) - memory.size - i32.const 16 - i32.shl - i32.const 54068 - i32.sub - i32.const 1 - i32.shr_u - global.set $~lib/rt/itcms/threshold - i32.const 1428 - i32.const 1424 - i32.store - i32.const 1432 - i32.const 1424 - i32.store - i32.const 1424 - global.set $~lib/rt/itcms/pinSpace - i32.const 1460 - i32.const 1456 - i32.store - i32.const 1464 - i32.const 1456 - i32.store - i32.const 1456 - global.set $~lib/rt/itcms/toSpace - i32.const 1604 - i32.const 1600 - i32.store - i32.const 1608 - i32.const 1600 - i32.store - i32.const 1600 - global.set $~lib/rt/itcms/fromSpace - call $start:assembly/instructions - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - call $assembly/memory/MaybePageFault#constructor - global.set $assembly/memory/NO_PAGE_FAULT - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - global.set $assembly/memory/EMPTY_UINT8ARRAY - i32.const -1 - i32.const 0 - call $assembly/memory-page/RawPage#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 0 - local.get $0 - call $assembly/memory-page/Page#constructor - global.set $assembly/memory/EMPTY_PAGE - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/arguments/Args#constructor (result i32) - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 6 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/arguments/Args.from (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/arguments/Args#constructor - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#get:length (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#subarray (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $4 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $4 - local.get $0 - i32.load - local.tee $5 - i32.store - local.get $4 - local.get $5 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $4 - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 0 - i32.lt_s - if (result i32) - local.get $1 - local.get $3 - i32.add - local.tee $0 - i32.const 0 - local.get $0 - i32.const 0 - i32.gt_s - select - else - local.get $1 - local.get $3 - local.get $1 - local.get $3 - i32.lt_s - select - end - local.tee $0 - i32.add - i32.store offset=4 - local.get $4 - local.get $2 - i32.const 0 - i32.lt_s - if (result i32) - local.get $2 - local.get $3 - i32.add - local.tee $1 - i32.const 0 - local.get $1 - i32.const 0 - i32.gt_s - select - else - local.get $2 - local.get $3 - local.get $2 - local.get $3 - i32.lt_s - select - end - local.tee $1 - local.get $0 - local.get $0 - local.get $1 - i32.lt_s - select - local.get $0 - i32.sub - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=8 - i32.ge_u - if - i32.const 1504 - i32.const 1744 - i32.const 167 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - i32.load8_u - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/arguments/decodeI32 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - local.get $2 - local.get $1 - local.get $1 - local.get $2 - i32.lt_u - select - call $~lib/typedarray/Uint8Array#subarray - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_u - local.set $2 - i32.const 0 - local.set $1 - loop $for-loop|0 - local.get $2 - local.get $3 - i32.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - local.get $3 - i32.const 3 - i32.shl - i32.shl - i32.or - local.set $1 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - i32.const 255 - i32.const 0 - local.get $2 - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $2 - i32.const 1 - i32.sub - call $~lib/typedarray/Uint8Array#__get - i32.const 128 - i32.and - else - i32.const 0 - end - select - local.set $0 - loop $for-loop|1 - local.get $2 - i32.const 4 - i32.lt_u - if - local.get $1 - local.get $0 - local.get $2 - i32.const 3 - i32.shl - i32.shl - i32.or - local.set $1 - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/arguments~anonymous|1 (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - local.get $1 - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/arguments/nibbles (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 2 - i32.const 9 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - call $~lib/object/Object#constructor - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store8 offset=1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.const 15 - i32.and - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.const 255 - i32.and - i32.const 4 - i32.shr_u - i32.store8 offset=1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/arguments/twoImm (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u - f64.convert_i32_u - f64.const 4 - f64.min - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - local.get $2 - call $assembly/arguments/decodeI32 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $2 - local.get $1 - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|2 (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - call $assembly/arguments/twoImm - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|4 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - local.get $1 - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#subarray@varargs (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $1 - end - i32.const 2147483647 - local.set $2 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - call $~lib/typedarray/Uint8Array#subarray - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/arguments/decodeU32 (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 2 - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 3 - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|5 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load8_u - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - local.get $0 - i32.const 1 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/arguments/decodeU32 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - local.get $0 - i32.const 5 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/arguments/decodeU32 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|6 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u offset=1 - f64.convert_i32_u - f64.const 4 - f64.min - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - local.get $3 - call $assembly/arguments/decodeI32 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - local.get $1 - call $assembly/arguments/decodeI32 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u - local.get $4 - local.get $0 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|8 (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u offset=1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|9 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load8_u offset=1 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load8_u - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - local.get $1 - call $assembly/arguments/decodeI32 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|11 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 1 - global.set $~argumentsLength - local.get $0 - i32.const 1 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.const 1 - i32.sub - i32.const 0 - local.get $1 - i32.const 1 - i32.gt_u - select - call $assembly/arguments/twoImm - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u offset=1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|12 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load8_u offset=1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load8_u - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/ensureCapacity (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=8 - local.tee $5 - local.get $2 - i32.shr_u - i32.gt_u - if - local.get $1 - i32.const 1073741820 - local.get $2 - i32.shr_u - i32.gt_u - if - i32.const 9200 - i32.const 9152 - i32.const 19 - i32.const 48 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $4 - i32.const 8 - local.get $1 - local.get $1 - i32.const 8 - i32.le_u - select - local.get $2 - i32.shl - local.set $1 - local.get $3 - if - i32.const 1073741820 - local.get $5 - i32.const 1 - i32.shl - local.tee $2 - local.get $2 - i32.const 1073741820 - i32.ge_u - select - local.tee $2 - local.get $1 - local.get $1 - local.get $2 - i32.lt_u - select - local.set $1 - end - block $__inlined_func$~lib/rt/itcms/__renew$2366 - local.get $4 - i32.const 20 - i32.sub - local.tee $3 - i32.load - i32.const -4 - i32.and - i32.const 16 - i32.sub - local.get $1 - i32.ge_u - if - local.get $3 - local.get $1 - i32.store offset=16 - local.get $4 - local.set $2 - br $__inlined_func$~lib/rt/itcms/__renew$2366 - end - local.get $1 - local.get $3 - i32.load offset=12 - call $~lib/rt/itcms/__new - local.tee $2 - local.get $4 - local.get $1 - local.get $3 - i32.load offset=16 - local.tee $3 - local.get $1 - local.get $3 - i32.lt_u - select - memory.copy - end - local.get $2 - local.get $4 - i32.ne - if - local.get $0 - local.get $2 - i32.store - local.get $0 - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - end - local.get $0 - local.get $1 - i32.store offset=8 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__set (param $0 i32) (param $1 i32) (param $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - local.get $1 - i32.const 0 - i32.lt_s - if - i32.const 1504 - i32.const 9152 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - i32.store offset=12 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 2320 - i32.store - i32.const 2320 - i32.const 0 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/MISSING_INSTRUCTION - global.get $~lib/memory/__stack_pointer - i32.const 2368 - i32.store - i32.const 2368 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/SBRK - global.get $~lib/memory/__stack_pointer - i32.const 231 - i32.const 2 - i32.const 10 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 2400 - i32.store - local.get $0 - i32.const 0 - i32.const 2400 - i32.const 0 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2432 - i32.store - local.get $0 - i32.const 1 - i32.const 2432 - i32.const 0 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 5 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 6 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 7 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 8 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 9 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2480 - i32.store - local.get $0 - i32.const 10 - i32.const 2480 - i32.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 11 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 12 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 13 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 14 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 15 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 16 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 17 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 18 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 19 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2512 - i32.store - local.get $0 - i32.const 20 - i32.const 2512 - i32.const 5 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 21 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 22 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 23 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 24 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 25 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 26 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 27 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 28 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 29 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2560 - i32.store - local.get $0 - i32.const 30 - i32.const 2560 - i32.const 2 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2608 - i32.store - local.get $0 - i32.const 31 - i32.const 2608 - i32.const 2 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2656 - i32.store - local.get $0 - i32.const 32 - i32.const 2656 - i32.const 2 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2704 - i32.store - local.get $0 - i32.const 33 - i32.const 2704 - i32.const 2 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 34 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 35 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 36 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 37 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 38 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 39 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2752 - i32.store - local.get $0 - i32.const 40 - i32.const 2752 - i32.const 3 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 41 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 42 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 43 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 44 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 45 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 46 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 47 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 48 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 49 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2784 - i32.store - local.get $0 - i32.const 50 - i32.const 2784 - i32.const 4 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2832 - i32.store - local.get $0 - i32.const 51 - i32.const 2832 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2880 - i32.store - local.get $0 - i32.const 52 - i32.const 2880 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2928 - i32.store - local.get $0 - i32.const 53 - i32.const 2928 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2976 - i32.store - local.get $0 - i32.const 54 - i32.const 2976 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3024 - i32.store - local.get $0 - i32.const 55 - i32.const 3024 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3072 - i32.store - local.get $0 - i32.const 56 - i32.const 3072 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3120 - i32.store - local.get $0 - i32.const 57 - i32.const 3120 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3168 - i32.store - local.get $0 - i32.const 58 - i32.const 3168 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3216 - i32.store - local.get $0 - i32.const 59 - i32.const 3216 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3264 - i32.store - local.get $0 - i32.const 60 - i32.const 3264 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3312 - i32.store - local.get $0 - i32.const 61 - i32.const 3312 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3360 - i32.store - local.get $0 - i32.const 62 - i32.const 3360 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 63 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 64 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 65 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 66 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 67 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 68 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 69 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3408 - i32.store - local.get $0 - i32.const 70 - i32.const 3408 - i32.const 6 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3472 - i32.store - local.get $0 - i32.const 71 - i32.const 3472 - i32.const 6 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3536 - i32.store - local.get $0 - i32.const 72 - i32.const 3536 - i32.const 6 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3600 - i32.store - local.get $0 - i32.const 73 - i32.const 3600 - i32.const 6 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 74 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 75 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 76 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 77 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 78 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 79 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3664 - i32.store - local.get $0 - i32.const 80 - i32.const 3664 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3712 - i32.store - local.get $0 - i32.const 81 - i32.const 3712 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3760 - i32.store - local.get $0 - i32.const 82 - i32.const 3760 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3808 - i32.store - local.get $0 - i32.const 83 - i32.const 3808 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3872 - i32.store - local.get $0 - i32.const 84 - i32.const 3872 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3936 - i32.store - local.get $0 - i32.const 85 - i32.const 3936 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4000 - i32.store - local.get $0 - i32.const 86 - i32.const 4000 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4064 - i32.store - local.get $0 - i32.const 87 - i32.const 4064 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4128 - i32.store - local.get $0 - i32.const 88 - i32.const 4128 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4192 - i32.store - local.get $0 - i32.const 89 - i32.const 4192 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4256 - i32.store - local.get $0 - i32.const 90 - i32.const 4256 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 91 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 92 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 93 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 94 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 95 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 96 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 97 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 98 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 99 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4320 - i32.store - local.get $0 - i32.const 100 - i32.const 4320 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 101 - global.get $assembly/instructions/SBRK - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4368 - i32.store - local.get $0 - i32.const 102 - i32.const 4368 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4432 - i32.store - local.get $0 - i32.const 103 - i32.const 4432 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4496 - i32.store - local.get $0 - i32.const 104 - i32.const 4496 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4560 - i32.store - local.get $0 - i32.const 105 - i32.const 4560 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4624 - i32.store - local.get $0 - i32.const 106 - i32.const 4624 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4688 - i32.store - local.get $0 - i32.const 107 - i32.const 4688 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4752 - i32.store - local.get $0 - i32.const 108 - i32.const 4752 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4800 - i32.store - local.get $0 - i32.const 109 - i32.const 4800 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4848 - i32.store - local.get $0 - i32.const 110 - i32.const 4848 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4896 - i32.store - local.get $0 - i32.const 111 - i32.const 4896 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 112 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 113 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 114 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 115 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 116 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 117 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 118 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 119 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4944 - i32.store - local.get $0 - i32.const 120 - i32.const 4944 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4992 - i32.store - local.get $0 - i32.const 121 - i32.const 4992 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5040 - i32.store - local.get $0 - i32.const 122 - i32.const 5040 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5088 - i32.store - local.get $0 - i32.const 123 - i32.const 5088 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5136 - i32.store - local.get $0 - i32.const 124 - i32.const 5136 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5184 - i32.store - local.get $0 - i32.const 125 - i32.const 5184 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5232 - i32.store - local.get $0 - i32.const 126 - i32.const 5232 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5280 - i32.store - local.get $0 - i32.const 127 - i32.const 5280 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5328 - i32.store - local.get $0 - i32.const 128 - i32.const 5328 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5376 - i32.store - local.get $0 - i32.const 129 - i32.const 5376 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5424 - i32.store - local.get $0 - i32.const 130 - i32.const 5424 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5472 - i32.store - local.get $0 - i32.const 131 - i32.const 5472 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5520 - i32.store - local.get $0 - i32.const 132 - i32.const 5520 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5568 - i32.store - local.get $0 - i32.const 133 - i32.const 5568 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5616 - i32.store - local.get $0 - i32.const 134 - i32.const 5616 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5648 - i32.store - local.get $0 - i32.const 135 - i32.const 5648 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5696 - i32.store - local.get $0 - i32.const 136 - i32.const 5696 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5744 - i32.store - local.get $0 - i32.const 137 - i32.const 5744 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5792 - i32.store - local.get $0 - i32.const 138 - i32.const 5792 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5840 - i32.store - local.get $0 - i32.const 139 - i32.const 5840 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5888 - i32.store - local.get $0 - i32.const 140 - i32.const 5888 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5936 - i32.store - local.get $0 - i32.const 141 - i32.const 5936 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5984 - i32.store - local.get $0 - i32.const 142 - i32.const 5984 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6032 - i32.store - local.get $0 - i32.const 143 - i32.const 6032 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6080 - i32.store - local.get $0 - i32.const 144 - i32.const 6080 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6144 - i32.store - local.get $0 - i32.const 145 - i32.const 6144 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6208 - i32.store - local.get $0 - i32.const 146 - i32.const 6208 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6272 - i32.store - local.get $0 - i32.const 147 - i32.const 6272 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6320 - i32.store - local.get $0 - i32.const 148 - i32.const 6320 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6368 - i32.store - local.get $0 - i32.const 149 - i32.const 6368 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6416 - i32.store - local.get $0 - i32.const 150 - i32.const 6416 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6464 - i32.store - local.get $0 - i32.const 151 - i32.const 6464 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6512 - i32.store - local.get $0 - i32.const 152 - i32.const 6512 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6560 - i32.store - local.get $0 - i32.const 153 - i32.const 6560 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6608 - i32.store - local.get $0 - i32.const 154 - i32.const 6608 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6656 - i32.store - local.get $0 - i32.const 155 - i32.const 6656 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6720 - i32.store - local.get $0 - i32.const 156 - i32.const 6720 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6784 - i32.store - local.get $0 - i32.const 157 - i32.const 6784 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6848 - i32.store - local.get $0 - i32.const 158 - i32.const 6848 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6896 - i32.store - local.get $0 - i32.const 159 - i32.const 6896 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6960 - i32.store - local.get $0 - i32.const 160 - i32.const 6960 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7008 - i32.store - local.get $0 - i32.const 161 - i32.const 7008 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 162 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 163 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 164 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 165 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 166 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 167 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 168 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 169 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7072 - i32.store - local.get $0 - i32.const 170 - i32.const 7072 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7120 - i32.store - local.get $0 - i32.const 171 - i32.const 7120 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7168 - i32.store - local.get $0 - i32.const 172 - i32.const 7168 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7216 - i32.store - local.get $0 - i32.const 173 - i32.const 7216 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7264 - i32.store - local.get $0 - i32.const 174 - i32.const 7264 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7312 - i32.store - local.get $0 - i32.const 175 - i32.const 7312 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 176 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 177 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 178 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 179 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7360 - i32.store - local.get $0 - i32.const 180 - i32.const 7360 - i32.const 11 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 181 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 182 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 183 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 184 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 185 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 186 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 187 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 188 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 189 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7424 - i32.store - local.get $0 - i32.const 190 - i32.const 7424 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7456 - i32.store - local.get $0 - i32.const 191 - i32.const 7456 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7488 - i32.store - local.get $0 - i32.const 192 - i32.const 7488 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7520 - i32.store - local.get $0 - i32.const 193 - i32.const 7520 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7568 - i32.store - local.get $0 - i32.const 194 - i32.const 7568 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7616 - i32.store - local.get $0 - i32.const 195 - i32.const 7616 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7664 - i32.store - local.get $0 - i32.const 196 - i32.const 7664 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7712 - i32.store - local.get $0 - i32.const 197 - i32.const 7712 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7760 - i32.store - local.get $0 - i32.const 198 - i32.const 7760 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7808 - i32.store - local.get $0 - i32.const 199 - i32.const 7808 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7856 - i32.store - local.get $0 - i32.const 200 - i32.const 7856 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7888 - i32.store - local.get $0 - i32.const 201 - i32.const 7888 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7920 - i32.store - local.get $0 - i32.const 202 - i32.const 7920 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7952 - i32.store - local.get $0 - i32.const 203 - i32.const 7952 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8000 - i32.store - local.get $0 - i32.const 204 - i32.const 8000 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8048 - i32.store - local.get $0 - i32.const 205 - i32.const 8048 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8096 - i32.store - local.get $0 - i32.const 206 - i32.const 8096 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8144 - i32.store - local.get $0 - i32.const 207 - i32.const 8144 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8192 - i32.store - local.get $0 - i32.const 208 - i32.const 8192 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8240 - i32.store - local.get $0 - i32.const 209 - i32.const 8240 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8288 - i32.store - local.get $0 - i32.const 210 - i32.const 8288 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8320 - i32.store - local.get $0 - i32.const 211 - i32.const 8320 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8352 - i32.store - local.get $0 - i32.const 212 - i32.const 8352 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8384 - i32.store - local.get $0 - i32.const 213 - i32.const 8384 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8432 - i32.store - local.get $0 - i32.const 214 - i32.const 8432 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8480 - i32.store - local.get $0 - i32.const 215 - i32.const 8480 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8528 - i32.store - local.get $0 - i32.const 216 - i32.const 8528 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8576 - i32.store - local.get $0 - i32.const 217 - i32.const 8576 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8624 - i32.store - local.get $0 - i32.const 218 - i32.const 8624 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8672 - i32.store - local.get $0 - i32.const 219 - i32.const 8672 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8720 - i32.store - local.get $0 - i32.const 220 - i32.const 8720 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8768 - i32.store - local.get $0 - i32.const 221 - i32.const 8768 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8816 - i32.store - local.get $0 - i32.const 222 - i32.const 8816 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8864 - i32.store - local.get $0 - i32.const 223 - i32.const 8864 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8912 - i32.store - local.get $0 - i32.const 224 - i32.const 8912 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8960 - i32.store - local.get $0 - i32.const 225 - i32.const 8960 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8992 - i32.store - local.get $0 - i32.const 226 - i32.const 8992 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 9024 - i32.store - local.get $0 - i32.const 227 - i32.const 9024 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 9056 - i32.store - local.get $0 - i32.const 228 - i32.const 9056 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 9088 - i32.store - local.get $0 - i32.const 229 - i32.const 9088 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 9120 - i32.store - local.get $0 - i32.const 230 - i32.const 9120 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/INSTRUCTIONS - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MaybePageFault#constructor (result i32) - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 11 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store8 offset=1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/typedarray/Uint8Array#constructor (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $1 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 3 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store - local.get $1 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=8 - local.get $0 - i32.const 1073741820 - i32.gt_u - if - i32.const 9200 - i32.const 9248 - i32.const 19 - i32.const 57 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.store - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory-page/Page#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 12 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $2 - local.get $1 - i32.store offset=4 - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/memory-page/RawPage#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 13 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $2 - local.get $1 - i32.store offset=4 - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i64) - (local $2 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 3 - i32.shl - i32.add - i64.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.const 3 - i32.shl - i32.add - local.get $2 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/OutcomeData#constructor (result i32) - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.const 19 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $start:assembly/instructions/bit~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.popcnt - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.popcnt - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.clz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.clz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.ctz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.ctz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.extend8_s - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.extend16_s - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.const 65535 - i32.and - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.tee $3 - i64.const 8 - i64.shr_u - i64.const 71777214294589695 - i64.and - local.get $3 - i64.const 71777214294589695 - i64.and - i64.const 8 - i64.shl - i64.or - local.tee $3 - i64.const 16 - i64.shr_u - i64.const 281470681808895 - i64.and - local.get $3 - i64.const 281470681808895 - i64.and - i64.const 16 - i64.shl - i64.or - i64.const 32 - i64.rotr - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/staticJump (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/branch~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.ne - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.ge_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.ne - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/jump~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/dJump (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/jump~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.add - i32.wrap_i64 - call $assembly/instructions/outcome/dJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/jump~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=4 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/jump~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=12 - i64.add - i32.wrap_i64 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/dJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_u offset=8 - i64.const 32 - i64.shl - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=4 - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Chunks#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 24 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $3 - local.get $0 - i32.store - local.get $3 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - i32.store offset=4 - local.get $3 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $3 - local.get $2 - i32.store offset=8 - local.get $3 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/Chunks#constructor@varargs (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $1 - i32.store - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $2 - i32.store offset=4 - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=20 - local.get $0 - local.get $1 - local.get $2 - call $assembly/memory/Chunks#constructor - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#find" (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.load offset=4 - i32.and - i32.const 2 - i32.shl - i32.add - i32.load - local.set $0 - loop $while-continue|0 - local.get $0 - if - local.get $0 - i32.load offset=8 - local.tee $2 - i32.const 1 - i32.and - if (result i32) - i32.const 0 - else - local.get $1 - local.get $0 - i32.load - i32.eq - end - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - local.get $2 - i32.const -2 - i32.and - local.set $0 - br $while-continue|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $"~lib/map/Map#has" (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $1 - i32.const -1028477379 - i32.mul - i32.const 374761397 - i32.add - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.tee $0 - local.get $0 - i32.const 15 - i32.shr_u - i32.xor - i32.const -2048144777 - i32.mul - local.tee $0 - local.get $0 - i32.const 13 - i32.shr_u - i32.xor - i32.const -1028477379 - i32.mul - local.tee $0 - local.get $0 - i32.const 16 - i32.shr_u - i32.xor - call $"~lib/map/Map#find" - i32.const 0 - i32.ne - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/PageData#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 25 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $3 - local.get $0 - i32.store - local.get $3 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - i32.store offset=4 - local.get $3 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/fault (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/memory/MaybePageFault#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 1 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $"~lib/map/Map#get" (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $1 - i32.const -1028477379 - i32.mul - i32.const 374761397 - i32.add - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.tee $0 - local.get $0 - i32.const 15 - i32.shr_u - i32.xor - i32.const -2048144777 - i32.mul - local.tee $0 - local.get $0 - i32.const 13 - i32.shr_u - i32.xor - i32.const -1028477379 - i32.mul - local.tee $0 - local.get $0 - i32.const 16 - i32.shr_u - i32.xor - call $"~lib/map/Map#find" - local.tee $0 - i32.eqz - if - i32.const 10400 - i32.const 10464 - i32.const 105 - i32.const 17 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory-page/Page#can (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - i32.const 2 - i32.eq - if (result i32) - i32.const 1 - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load - i32.eq - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#fill@varargs (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $1of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 2147483647 - local.set $1 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.tee $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.le_s - select - local.tee $3 - local.get $1 - local.get $2 - local.get $1 - local.get $2 - i32.lt_s - select - local.tee $1 - i32.lt_s - if - local.get $3 - local.get $4 - i32.add - i32.const 0 - local.get $1 - local.get $3 - i32.sub - memory.fill - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory-page/RawPage#get:data (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 4096 - call $~lib/typedarray/Uint8Array#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - i32.const 1 - global.set $~argumentsLength - local.get $1 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 10640 - i32.const 42 - i32.const 12 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/memory/Memory#getChunks (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner3 (result i32) - block $folding-inner2 - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $3 - i32.const 255 - i32.and - i32.eqz - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $0 - i32.store - br $folding-inner2 - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $2 - i32.const 4095 - i32.and - local.set $5 - local.get $2 - i32.const 12 - i32.shr_u - local.tee $6 - i32.const 12 - i32.shl - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $8 - i32.store - block $__inlined_func$assembly/memory/Memory#getPage$2371 (result i32) - local.get $8 - local.get $6 - call $"~lib/map/Map#has" - i32.eqz - if - local.get $7 - call $assembly/memory/fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_PAGE - local.tee $7 - i32.store offset=4 - local.get $6 - local.get $7 - local.get $5 - call $assembly/memory/PageData#constructor - br $__inlined_func$assembly/memory/Memory#getPage$2371 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $8 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - local.get $6 - call $"~lib/map/Map#get" - local.tee $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $1 - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $7 - call $assembly/memory/fault - local.tee $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 1 - i32.store8 offset=1 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_PAGE - local.tee $7 - i32.store offset=4 - local.get $6 - local.get $7 - local.get $5 - call $assembly/memory/PageData#constructor - br $__inlined_func$assembly/memory/Memory#getPage$2371 - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $7 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $7 - local.get $6 - local.get $5 - call $assembly/memory/PageData#constructor - end - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $4 - i32.store - local.get $4 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $0 - i32.store - br $folding-inner2 - end - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $4 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.load offset=8 - local.tee $5 - local.get $3 - i32.const 255 - i32.and - i32.add - local.tee $6 - i32.const 4096 - i32.le_u - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load offset=4 - local.tee $1 - i32.store offset=8 - local.get $1 - call $assembly/memory-page/RawPage#get:data - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $5 - local.get $6 - call $~lib/typedarray/Uint8Array#subarray - local.tee $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 2 - global.set $~argumentsLength - local.get $1 - local.get $0 - call $assembly/memory/Chunks#constructor@varargs - br $folding-inner3 - end - local.get $2 - local.get $3 - i32.const 255 - i32.and - i32.add - i64.extend_i32_u - i64.const 4294967295 - i64.and - i32.wrap_i64 - i32.const 12 - i32.shr_u - local.tee $2 - i32.const 12 - i32.shl - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $7 - i32.store - block $folding-inner0 - local.get $7 - local.get $2 - call $"~lib/map/Map#has" - i32.eqz - if - local.get $6 - call $assembly/memory/fault - local.set $0 - br $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $2 - call $"~lib/map/Map#get" - local.tee $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $6 - call $assembly/memory/fault - local.tee $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store8 offset=1 - br $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load offset=4 - local.tee $2 - i32.store offset=8 - local.get $2 - call $assembly/memory-page/RawPage#get:data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - i32.const 1 - global.set $~argumentsLength - local.get $2 - local.get $5 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $1 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=8 - local.get $0 - call $assembly/memory-page/RawPage#get:data - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - local.get $5 - local.get $3 - i32.const 255 - i32.and - i32.add - i32.const 4096 - i32.sub - call $~lib/typedarray/Uint8Array#subarray - local.tee $0 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - local.get $2 - local.get $1 - local.get $0 - call $assembly/memory/Chunks#constructor - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - br $folding-inner2 - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - i32.const 1 - global.set $~argumentsLength - local.get $0 - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - end - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/ChunkBytes#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 22 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $2 - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $2 - local.get $1 - i32.store offset=4 - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.add - local.get $2 - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getBytes (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 1 - local.get $1 - local.get $2 - call $assembly/memory/Memory#getChunks - local.tee $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $0 - i32.store - local.get $0 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $0 - i32.store - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $~lib/staticarray/StaticArray#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $0 - local.get $1 - call $assembly/memory/ChunkBytes#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=8 - local.tee $4 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.const 255 - i32.and - call $~lib/staticarray/StaticArray#constructor - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $6 - loop $for-loop|0 - local.get $3 - local.get $6 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $2 - local.get $3 - local.get $0 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - i32.const 0 - local.set $0 - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $2 - local.get $0 - local.get $6 - i32.add - local.get $4 - local.get $0 - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $0 - i32.const 1 - i32.add - local.set $0 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $0 - local.get $2 - call $assembly/memory/ChunkBytes#constructor - local.set $0 - br $folding-inner1 - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/memory/Result#constructor (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 21 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - call $assembly/memory/MaybePageFault#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.add - i32.load8_u - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getU8 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/instructions/outcome/okOrFault (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 2 - i32.const 1 - local.get $0 - i32.load8_u offset=1 - select - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.load offset=4 - i32.store offset=16 - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getU8 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getI8 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i32.extend8_s - i64.extend_i32_s - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getI8 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getU16 (param $0 i32) (param $1 i32) (result i32) - (local $2 i64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.store offset=8 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $0 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getU16 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getI16 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - local.get $2 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i32.or - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $0 - i32.extend16_s - i64.extend_i32_s - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getI16 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getU32 (param $0 i32) (param $1 i32) (result i32) - (local $2 i64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.store offset=8 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i64.extend_i32_u - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $0 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i64.extend_i32_u - i64.or - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getU32 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getI32 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - local.get $2 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store - local.get $3 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store - local.get $3 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i32.or - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $0 - i64.extend_i32_s - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getI32 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getU64 (param $0 i32) (param $1 i32) (result i32) - (local $2 i64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 8 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.store offset=8 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 8 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 16 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 24 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 4 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 32 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 5 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 40 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 6 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 48 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $0 - i32.const 7 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 56 - i64.shl - i64.or - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getU64 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getU8 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getI8 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getU16 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getI16 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getU32 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getI32 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getU64 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.xor - i64.const -1 - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $3 - local.get $5 - i64.add - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_u offset=8 - i64.mul - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_u offset=8 - i64.const 4294967296 - i64.or - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $4 - i32.add - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 4294967296 - i64.add - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - i64.sub - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.mul - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.tee $2 - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.div_u - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const -1 - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.extend32_s - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.extend32_s - local.tee $4 - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const -1 - call $~lib/staticarray/StaticArray#__set - else - local.get $3 - i64.const -2147483648 - i64.eq - local.get $4 - i64.const -1 - i64.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $3 - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $3 - local.get $4 - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - local.get $2 - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.rem_u - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.tee $4 - if - local.get $2 - i32.const -2147483648 - i32.eq - local.get $4 - i32.const -1 - i32.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_s - local.get $4 - i64.extend_i32_s - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.sub - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const -1 - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.div_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|17 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.tee $4 - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const -1 - call $~lib/staticarray/StaticArray#__set - else - local.get $3 - i64.const -9223372036854775808 - i64.eq - local.get $4 - i64.const -1 - i64.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $3 - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $3 - local.get $4 - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|18 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.rem_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|19 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.tee $4 - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $3 - call $~lib/staticarray/StaticArray#__set - else - local.get $3 - i64.const -9223372036854775808 - i64.eq - local.get $4 - i64.const -1 - i64.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $3 - local.get $4 - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|20 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - (local $6 i64) - (local $7 i64) - (local $8 i64) - (local $9 i64) - (local $10 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - block $__inlined_func$assembly/instructions/utils/mulUpperSigned$4 (result i64) - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - local.get $4 - i64.const 0 - i64.lt_s - if (result i32) - local.get $4 - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $4 - i32.const 1 - else - i32.const 0 - end - local.set $0 - local.get $3 - i64.const 0 - i64.lt_s - if (result i32) - local.get $3 - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $3 - local.get $0 - i32.eqz - else - local.get $0 - end - if - local.get $3 - i64.const 32 - i64.shr_u - local.tee $8 - local.get $4 - i64.const 4294967295 - i64.and - local.tee $5 - i64.mul - local.set $6 - local.get $4 - i64.const 32 - i64.shr_u - local.tee $7 - local.get $3 - i64.const 4294967295 - i64.and - local.tee $9 - i64.mul - local.set $10 - local.get $3 - local.get $4 - i64.mul - i64.eqz - i64.extend_i32_u - local.get $7 - local.get $8 - i64.mul - local.get $6 - i64.const 32 - i64.shr_u - i64.add - local.get $10 - i64.const 32 - i64.shr_u - i64.add - local.get $6 - i64.const 4294967295 - i64.and - local.get $5 - local.get $9 - i64.mul - i64.const 32 - i64.shr_u - i64.add - local.get $10 - i64.const 4294967295 - i64.and - i64.add - i64.const 32 - i64.shr_u - i64.add - i64.const -1 - i64.xor - i64.add - br $__inlined_func$assembly/instructions/utils/mulUpperSigned$4 - end - local.get $3 - i64.const 32 - i64.shr_u - local.tee $5 - local.get $4 - i64.const 4294967295 - i64.and - local.tee $6 - i64.mul - local.set $7 - local.get $4 - i64.const 32 - i64.shr_u - local.tee $4 - local.get $5 - i64.mul - local.get $7 - i64.const 32 - i64.shr_u - i64.add - local.get $3 - i64.const 4294967295 - i64.and - local.tee $3 - local.get $4 - i64.mul - local.tee $4 - i64.const 32 - i64.shr_u - i64.add - local.get $7 - i64.const 4294967295 - i64.and - local.get $3 - local.get $6 - i64.mul - i64.const 32 - i64.shr_u - i64.add - local.get $4 - i64.const 4294967295 - i64.and - i64.add - i64.const 32 - i64.shr_u - i64.add - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|21 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - (local $6 i64) - (local $7 i64) - (local $8 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.tee $5 - i64.const 32 - i64.shr_u - local.set $6 - local.get $4 - i64.const 32 - i64.shr_u - local.tee $7 - local.get $5 - i64.const 4294967295 - i64.and - local.tee $5 - i64.mul - local.set $8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $6 - local.get $7 - i64.mul - local.get $4 - i64.const 4294967295 - i64.and - local.tee $3 - local.get $6 - i64.mul - local.tee $4 - i64.const 32 - i64.shr_u - i64.add - local.get $8 - i64.const 32 - i64.shr_u - i64.add - local.get $4 - i64.const 4294967295 - i64.and - local.get $3 - local.get $5 - i64.mul - i64.const 32 - i64.shr_u - i64.add - local.get $8 - i64.const 4294967295 - i64.and - i64.add - i64.const 32 - i64.shr_u - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|22 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - (local $6 i64) - (local $7 i64) - (local $8 i64) - (local $9 i64) - (local $10 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2376 (result i64) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $5 - local.get $3 - i64.const 0 - i64.lt_s - if - local.get $3 - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.tee $6 - i64.const 4294967295 - i64.and - local.tee $7 - local.get $5 - i64.const 32 - i64.shr_u - local.tee $8 - i64.mul - local.set $3 - local.get $6 - i64.const 32 - i64.shr_u - local.tee $4 - local.get $5 - i64.const 4294967295 - i64.and - local.tee $9 - i64.mul - local.set $10 - local.get $5 - local.get $6 - i64.mul - i64.eqz - i64.extend_i32_u - local.get $4 - local.get $8 - i64.mul - local.get $3 - i64.const 32 - i64.shr_u - i64.add - local.get $10 - i64.const 32 - i64.shr_u - i64.add - local.get $3 - i64.const 4294967295 - i64.and - local.get $7 - local.get $9 - i64.mul - i64.const 32 - i64.shr_u - i64.add - local.get $10 - i64.const 4294967295 - i64.and - i64.add - i64.const 32 - i64.shr_u - i64.add - i64.const -1 - i64.xor - i64.add - br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2376 - end - local.get $3 - i64.const 4294967295 - i64.and - local.tee $4 - local.get $5 - i64.const 32 - i64.shr_u - local.tee $6 - i64.mul - local.set $7 - local.get $3 - i64.const 32 - i64.shr_u - local.tee $3 - local.get $5 - i64.const 4294967295 - i64.and - local.tee $5 - i64.mul - local.set $8 - local.get $3 - local.get $6 - i64.mul - local.get $7 - i64.const 32 - i64.shr_u - i64.add - local.get $8 - i64.const 32 - i64.shr_u - i64.add - local.get $7 - i64.const 4294967295 - i64.and - local.get $4 - local.get $5 - i64.mul - i64.const 32 - i64.shr_u - i64.add - local.get $8 - i64.const 4294967295 - i64.and - i64.add - i64.const 32 - i64.shr_u - i64.add - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|23 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $3 - local.get $3 - local.get $4 - i64.lt_s - select - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|24 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $3 - local.get $3 - local.get $4 - i64.lt_u - select - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|25 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $3 - local.get $3 - local.get $4 - i64.gt_s - select - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|26 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $3 - local.get $3 - local.get $4 - i64.gt_u - select - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.rotr - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_s offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.rotr - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $0 - i32.load offset=8 - i32.rotr - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=8 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.rotr - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.rotl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.rotl - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.rotr - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.rotr - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.lt_u - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.lt_s - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.gt_u - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.gt_s - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.gt_u - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.gt_s - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 31 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.shl - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 31 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.shr_u - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 31 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.extend32_s - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i32.load offset=8 - local.get $2 - i32.shl - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i32.load offset=8 - local.get $2 - i32.shr_u - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i64.extend_i32_u - i64.shr_s - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 63 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $2 - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 63 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $2 - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 63 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - local.get $2 - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - local.get $2 - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i64.extend_i32_u - i64.shr_s - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.shl - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.shr_u - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.extend32_s - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i64.extend_i32_u - i64.shr_s - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $2 - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $2 - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|17 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $2 - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#__set (param $0 i32) (param $1 i32) (param $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=8 - i32.ge_u - if - i32.const 1504 - i32.const 1744 - i32.const 178 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - local.get $2 - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 2 - local.get $1 - i32.const 1 - call $assembly/memory/Memory#getChunks - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - local.get $1 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $1 - i32.store - local.get $1 - i32.const 0 - local.get $2 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=4 - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 2 - local.get $1 - i32.const 2 - call $assembly/memory/Memory#getChunks - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - local.get $1 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $1 - i32.store - local.get $1 - i32.const 0 - local.get $2 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $1 - i32.store - local.get $1 - i32.const 1 - local.get $2 - i32.const 65535 - i32.and - i32.const 8 - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $1 - i32.store - local.get $1 - i32.const 0 - local.get $2 - i32.const 65535 - i32.and - i32.const 8 - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=4 - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU32 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 2 - local.get $1 - i32.const 4 - call $assembly/memory/Memory#getChunks - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $0 - i32.store - local.get $0 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - loop $for-loop|0 - local.get $3 - local.get $4 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - local.get $3 - local.get $2 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 8 - i32.shr_u - local.set $2 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - i32.const 0 - local.set $3 - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $3 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - local.get $3 - local.get $2 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 8 - i32.shr_u - local.set $2 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#setU32 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU64 (param $0 i32) (param $1 i32) (param $2 i64) (result i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 2 - local.get $1 - i32.const 8 - call $assembly/memory/Memory#getChunks - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $0 - i32.store - local.get $0 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - loop $for-loop|0 - local.get $3 - local.get $4 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - local.get $3 - local.get $2 - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i64.const 8 - i64.shr_u - local.set $2 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - i32.const 0 - local.set $3 - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $3 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - local.get $3 - local.get $2 - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i64.const 8 - i64.shr_u - local.set $2 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i64.load32_s offset=4 - call $assembly/memory/Memory#setU64 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.add - i32.wrap_i64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=8 - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.add - i32.wrap_i64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=8 - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.add - i32.wrap_i64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=8 - call $assembly/memory/Memory#setU32 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.add - i32.wrap_i64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i64.load32_s offset=8 - call $assembly/memory/Memory#setU64 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/misc~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/array/Array#get:length (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/console/console.log (param $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/bindings/dom/console.log - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory-page/Arena#acquire (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length - i32.const 0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load offset=12 - local.tee $0 - i32.const 0 - i32.le_s - if - i32.const 14144 - i32.const 9152 - i32.const 271 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.get $0 - i32.const 1 - i32.sub - local.tee $0 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 12 - i32.shl - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 14192 - i32.store - i32.const 14192 - call $~lib/console/console.log - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 536870912 - i32.lt_u - if (result i32) - i32.const 4096 - call $~lib/typedarray/Uint8Array#constructor - else - i32.const 0 - end - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=8 - i32.const 1 - i32.add - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/memory-page/RawPage#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $"~lib/map/Map#set" (param $0 i32) (param $1 i32) (param $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $1 - i32.const -1028477379 - i32.mul - i32.const 374761397 - i32.add - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.tee $3 - local.get $3 - i32.const 15 - i32.shr_u - i32.xor - i32.const -2048144777 - i32.mul - local.tee $3 - local.get $3 - i32.const 13 - i32.shr_u - i32.xor - i32.const -1028477379 - i32.mul - local.tee $3 - local.get $3 - i32.const 16 - i32.shr_u - i32.xor - local.tee $8 - call $"~lib/map/Map#find" - local.tee $3 - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $3 - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=12 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=12 - i32.const 3 - i32.mul - i32.const 4 - i32.div_s - i32.lt_s - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - i32.const 1 - i32.shl - i32.const 1 - i32.or - end - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.shl - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $10 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.const 3 - i32.shl - i32.const 3 - i32.div_s - local.tee $7 - i32.const 12 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=8 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $11 - local.get $0 - i32.load offset=16 - i32.const 12 - i32.mul - i32.add - local.set $6 - local.get $4 - local.set $3 - loop $while-continue|0 - local.get $6 - local.get $11 - i32.ne - if - local.get $11 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - local.get $3 - local.get $11 - i32.load - local.tee $12 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=4 - local.tee $5 - i32.store offset=8 - local.get $3 - local.get $5 - i32.store offset=4 - local.get $3 - local.get $10 - local.get $9 - local.get $12 - i32.const -1028477379 - i32.mul - i32.const 374761397 - i32.add - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.tee $5 - i32.const 15 - i32.shr_u - local.get $5 - i32.xor - i32.const -2048144777 - i32.mul - local.tee $5 - i32.const 13 - i32.shr_u - local.get $5 - i32.xor - i32.const -1028477379 - i32.mul - local.tee $5 - i32.const 16 - i32.shr_u - local.get $5 - i32.xor - i32.and - i32.const 2 - i32.shl - i32.add - local.tee $5 - i32.load - i32.store offset=8 - local.get $5 - local.get $3 - i32.store - local.get $3 - i32.const 12 - i32.add - local.set $3 - end - local.get $11 - i32.const 12 - i32.add - local.set $11 - br $while-continue|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $0 - local.get $10 - i32.store - local.get $0 - local.get $10 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $0 - local.get $4 - i32.store offset=8 - local.get $0 - local.get $4 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - local.get $7 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $0 - local.get $0 - i32.load offset=20 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=16 - local.tee $4 - i32.const 1 - i32.add - i32.store offset=16 - local.get $3 - local.get $4 - i32.const 12 - i32.mul - i32.add - local.tee $3 - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $3 - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=20 - i32.const 1 - i32.add - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $3 - local.get $1 - local.get $8 - local.get $0 - i32.load offset=4 - i32.and - i32.const 2 - i32.shl - i32.add - local.tee $0 - i32.load - i32.store offset=8 - local.get $0 - local.get $3 - i32.store - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $start:assembly/instructions/misc~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $6 - local.get $2 - i64.load32_u offset=12 - i64.store - block $folding-inner0 - local.get $4 - i32.eqz - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i64.load32_u offset=12 - local.get $4 - i64.extend_i32_u - i64.add - local.tee $3 - i64.const 4294967296 - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=8 - local.tee $2 - i32.store offset=4 - local.get $2 - i32.const 1 - i32.store8 - br $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $3 - i64.store32 offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $3 - i64.const 1 - i64.sub - i64.const 12 - i64.shr_s - i32.wrap_i64 - local.tee $5 - local.get $2 - i32.load - i32.eq - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.load - i32.const 1 - i32.add - local.set $4 - loop $for-loop|0 - local.get $4 - local.get $5 - i32.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - local.tee $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - call $assembly/memory-page/Arena#acquire - local.tee $7 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - i32.const 2 - local.get $7 - call $assembly/memory-page/Page#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $8 - local.get $4 - local.get $7 - call $"~lib/map/Map#set" - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $5 - i32.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - i32.load8_u - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/codec~anonymous|0 (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15344 - i32.store - i32.const 15344 - call $~lib/array/Array#get:length - local.set $2 - loop $for-loop|0 - local.get $1 - local.get $2 - i32.const 255 - i32.and - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - i32.const 15344 - i32.store - i32.const 15344 - local.get $1 - call $~lib/array/Array#__get - local.get $0 - i32.const 255 - i32.and - i32.le_u - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 8 - local.get $1 - i32.sub - return - end - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $assembly/program/liftBytes (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - call $~lib/array/Array#get:length - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.lt_s - if - i32.const 1504 - i32.const 1744 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=4 - local.get $2 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/codec/Decoder#constructor (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 38 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/util/string/joinStringArray (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $1 - i32.const 1 - i32.sub - local.tee $5 - i32.const 0 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15424 - return - end - local.get $5 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - i32.const 15424 - local.get $0 - select - return - end - loop $for-loop|0 - local.get $1 - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $4 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $6 - i32.store offset=4 - local.get $6 - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $3 - local.get $6 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - i32.add - local.set $3 - end - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|0 - end - end - i32.const 0 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $2 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - local.tee $1 - local.get $5 - i32.mul - i32.add - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $6 - i32.store offset=12 - i32.const 0 - local.set $3 - loop $for-loop|1 - local.get $3 - local.get $5 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $3 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $7 - i32.store offset=4 - local.get $7 - if - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $6 - local.get $4 - i32.const 1 - i32.shl - i32.add - local.get $7 - local.get $7 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - local.tee $7 - i32.const 1 - i32.shl - memory.copy - local.get $4 - local.get $7 - i32.add - local.set $4 - end - local.get $1 - if - local.get $6 - local.get $4 - i32.const 1 - i32.shl - i32.add - local.get $2 - local.get $1 - i32.const 1 - i32.shl - memory.copy - local.get $1 - local.get $4 - i32.add - local.set $4 - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $5 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $0 - i32.store offset=4 - local.get $0 - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $6 - local.get $4 - i32.const 1 - i32.shl - i32.add - local.get $0 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - memory.copy - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store - local.get $0 - local.get $1 - i32.const 15424 - call $~lib/util/string/joinStringArray - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/Decoder#ensureBytes (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - call $~lib/typedarray/Uint8Array#get:length - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - i32.sub - call $~lib/number/I32#toString - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 15584 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 15588 - local.get $1 - i32.store - i32.const 15584 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 15584 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 15596 - local.get $0 - i32.store - i32.const 15584 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 15584 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=4 - i32.const 15584 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 17408 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/ValOffset#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 40 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/codec/Decoder#varU32 (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=4 - local.set $4 - i32.const 1 - global.set $~argumentsLength - local.get $1 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - i32.const 1 - global.set $~argumentsLength - i32.const 15392 - i32.load - call_indirect (type $2) - i32.const 255 - i32.and - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $1 - block $__inlined_func$assembly/codec/decodeVarU32$1 (result i32) - local.get $5 - i32.eqz - if - local.get $1 - i32.const 1 - call $assembly/codec/ValOffset#constructor - br $__inlined_func$assembly/codec/decodeVarU32$1 - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $5 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $5 - call $~lib/number/I32#toString - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - call $~lib/number/I32#toString - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 17632 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - i32.const 17636 - local.get $0 - i32.store - i32.const 17632 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 17632 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - i32.const 17644 - local.get $1 - i32.store - i32.const 17632 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 17632 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=12 - i32.const 17632 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 17408 - i32.const 108 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.const 1 - i32.const 8 - local.get $5 - i32.sub - local.tee $1 - i32.shl - i32.const 0 - local.get $1 - i32.const 32 - i32.lt_u - select - i32.add - i32.const 256 - i32.sub - local.get $5 - i32.const 3 - i32.shl - i32.shl - local.set $6 - local.get $5 - i32.const 1 - i32.sub - local.set $1 - loop $for-loop|0 - local.get $1 - i32.const 0 - i32.ge_s - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $1 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - local.get $2 - i32.const 8 - i32.shl - i32.add - local.set $2 - local.get $1 - i32.const 1 - i32.sub - local.set $1 - br $for-loop|0 - end - end - local.get $2 - local.get $6 - i32.add - local.get $5 - i32.const 1 - i32.add - call $assembly/codec/ValOffset#constructor - end - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $2 - local.get $1 - i32.load offset=4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/codec/Decoder#bytes (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/string/String#concat (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - local.tee $3 - local.get $2 - i32.add - local.tee $4 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15424 - return - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $4 - i32.store offset=4 - local.get $4 - local.get $0 - local.get $2 - memory.copy - local.get $2 - local.get $4 - i32.add - local.get $1 - local.get $3 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/string/String.__concat (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - call $~lib/string/String#concat - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/index/disassemble~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - i32.const 255 - i32.and - i32.const 16 - call $~lib/util/number/utoa32 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 15824 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 15824 - i32.store - block $__inlined_func$~lib/string/String#padStart$2455 - i32.const 15820 - i32.load - i32.const -2 - i32.and - local.tee $2 - i32.eqz - local.get $5 - i32.const 4 - i32.gt_u - i32.or - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#padStart$2455 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store offset=4 - i32.const 4 - local.get $5 - i32.sub - local.tee $4 - local.get $2 - i32.gt_u - if - local.get $4 - local.get $4 - i32.const 2 - i32.sub - local.get $2 - i32.div_u - local.get $2 - i32.mul - local.tee $7 - i32.sub - local.set $8 - loop $while-continue|0 - local.get $6 - local.get $7 - i32.lt_u - if - local.get $3 - local.get $6 - i32.add - i32.const 15824 - local.get $2 - memory.copy - local.get $2 - local.get $6 - i32.add - local.set $6 - br $while-continue|0 - end - end - local.get $3 - local.get $7 - i32.add - i32.const 15824 - local.get $8 - memory.copy - else - local.get $3 - i32.const 15824 - local.get $4 - memory.copy - end - local.get $3 - local.get $4 - i32.add - local.get $1 - local.get $5 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - local.set $1 - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - call $~lib/string/String.__concat - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/codec/Decoder#u8 (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - local.get $0 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=4 - i32.const 1 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.const 2 - i32.shl - i32.add - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/Mask#isInstruction (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i64.extend_i32_s - local.get $1 - i64.extend_i32_u - i64.le_u - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - i32.eqz - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/Mask#skipBytesToNextInstruction (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $1 - i32.const 1 - i32.add - local.tee $1 - local.get $2 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $0 - i32.eqz - if - i32.const 17824 - i32.const 9152 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/BasicBlocks#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 34 - call $~lib/rt/itcms/__new - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store - local.get $4 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $5 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $5 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.const 2 - i32.shl - i32.const 35 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.const 2 - call $~lib/staticarray/StaticArray#__set - loop $for-loop|0 - local.get $3 - local.get $5 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $3 - call $assembly/program/Mask#isInstruction - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $3 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $6 - i32.store offset=4 - local.get $6 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $6 - local.get $0 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#__get - end - i32.load8_u offset=16 - if - local.get $5 - local.get $3 - i32.const 1 - i32.add - local.get $7 - i32.add - local.tee $6 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $6 - i32.const 2 - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - local.get $3 - local.get $2 - local.get $3 - call $~lib/staticarray/StaticArray#__get - i32.const 4 - i32.or - call $~lib/staticarray/StaticArray#__set - end - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $4 - local.get $2 - i32.store - local.get $4 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/program/deblob (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i64) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i64) - (local $10 i64) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $14 i32) - (local $15 i32) - (local $16 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/codec/Decoder#constructor - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/codec/Decoder#varU32 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/codec/Decoder#u8 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/codec/Decoder#varU32 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - local.get $5 - i32.mul - call $assembly/codec/Decoder#bytes - local.tee $14 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $11 - call $assembly/codec/Decoder#bytes - local.tee $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $11 - i32.const 7 - i32.add - i32.const 3 - i32.shr_u - call $assembly/codec/Decoder#bytes - local.tee $12 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - global.get $~lib/memory/__stack_pointer - block $__inlined_func$assembly/program/Mask#constructor$11 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 31 - call $~lib/rt/itcms/__new - local.tee $13 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=4 - local.get $13 - i32.const 0 - i32.store - local.get $13 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $11 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.const 2 - i32.shl - i32.const 32 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $13 - local.get $0 - i32.store - local.get $13 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.sub - local.set $1 - loop $for-loop|0 - local.get $1 - i32.const 0 - i32.ge_s - if - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $1 - call $~lib/typedarray/Uint8Array#__get - local.set $0 - local.get $1 - i32.const 3 - i32.shl - local.set $15 - i32.const 7 - local.set $2 - loop $for-loop|2 - local.get $2 - i32.const 0 - i32.ge_s - if - local.get $0 - i32.const 128 - i32.and - local.set $16 - local.get $0 - i32.const 1 - i32.shl - local.set $0 - local.get $2 - local.get $15 - i32.add - local.tee $7 - local.get $11 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.load - local.tee $8 - i32.store offset=4 - local.get $8 - local.get $7 - i32.const 25 - i32.const 0 - local.get $6 - i32.const 1 - i32.add - local.get $16 - select - local.tee $6 - local.get $6 - i32.const 25 - i32.ge_u - select - call $~lib/staticarray/StaticArray#__set - end - local.get $2 - i32.const 1 - i32.sub - local.set $2 - br $for-loop|2 - end - end - local.get $1 - i32.const 1 - i32.sub - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - br $__inlined_func$assembly/program/Mask#constructor$11 - end - br $folding-inner1 - end - local.tee $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 33 - call $~lib/rt/itcms/__new - local.tee $7 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - i32.const 0 - i32.store - local.get $7 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.const 255 - i32.and - local.tee $1 - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.div_s - else - i32.const 0 - end - call $~lib/staticarray/StaticArray#constructor - local.tee $8 - i32.store offset=8 - i32.const 0 - local.set $1 - loop $for-loop|01 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.gt_s - if - i64.const 0 - local.set $4 - local.get $5 - i32.const 1 - i32.sub - i32.const 255 - i32.and - local.set $2 - loop $for-loop|1 - local.get $2 - i32.const 0 - i32.ge_s - if - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - i64.const -1 - local.get $4 - i64.const 8 - i64.shl - local.tee $9 - local.get $14 - local.get $1 - local.get $2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i64.extend_i32_u - i64.add - local.tee $10 - local.get $4 - local.get $10 - i64.gt_u - local.get $4 - local.get $9 - i64.gt_u - i32.or - select - local.set $4 - local.get $2 - i32.const 1 - i32.sub - local.set $2 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $1 - local.get $5 - i32.const 255 - i32.and - local.tee $2 - i32.div_s - local.get $4 - call $~lib/staticarray/StaticArray#__set - local.get $1 - local.get $2 - i32.add - local.set $1 - br $for-loop|01 - end - end - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $7 - local.get $8 - i32.store - local.get $7 - local.get $8 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $0 - call $assembly/program/BasicBlocks#constructor - local.tee $1 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 30 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $2 - local.get $3 - i32.store - local.get $2 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $2 - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $2 - local.get $7 - i32.store offset=8 - local.get $2 - local.get $7 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $2 - local.get $1 - i32.store offset=12 - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $0 - i32.store offset=4 - local.get $0 - i32.eqz - if - i32.const 17824 - i32.const 9152 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/program/decodeArguments (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 1264 - i32.store - i32.const 1264 - local.get $0 - call $~lib/array/Array#__get - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 1264 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 1264 - local.get $0 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#constructor - local.tee $4 - i32.store offset=4 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $3 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $4 - local.get $3 - local.get $1 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - i32.const 2 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 2272 - i32.store offset=8 - local.get $4 - local.get $2 - i32.const 2272 - local.get $0 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $1) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 2 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 2272 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 2272 - local.get $0 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $1) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-generic/getAssembly (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $4 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 17952 - return - end - i32.const 15424 - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - loop $for-loop|0 - local.get $3 - local.get $4 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - local.get $2 - local.get $3 - call $assembly/program/Mask#isInstruction - i32.eqz - if - i32.const 18032 - i32.const 18144 - i32.const 46 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - local.set $2 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $5 - i32.store - local.get $2 - local.get $5 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $5 - i32.store - local.get $5 - local.get $2 - call $~lib/array/Array#__get - end - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 18224 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 18224 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - call $~lib/number/I32#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 18256 - i32.store offset=16 - local.get $7 - i32.const 18256 - call $~lib/string/String#concat - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $1 - local.get $7 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $6 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.const 255 - i32.and - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $2 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 18352 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - i32.const 18356 - local.get $2 - i32.store - i32.const 18352 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 18352 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=16 - i32.const 18352 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - local.get $2 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - local.get $2 - local.get $3 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $8 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - local.get $8 - local.get $3 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $6 - call $assembly/program/decodeArguments - local.tee $2 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - i32.const 42 - i32.const 0 - call $~lib/rt/__newArray - local.tee $8 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 0 - local.get $2 - i32.load - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 1 - local.get $2 - i32.load offset=4 - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 2 - local.get $2 - i32.load offset=8 - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 3 - local.get $2 - i32.load offset=12 - call $~lib/array/Array#__set - local.get $8 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 1136 - i32.store - i32.const 1136 - local.get $5 - i32.load offset=4 - call $~lib/array/Array#__get - local.set $5 - i32.const 0 - local.set $2 - loop $for-loop|1 - local.get $2 - local.get $5 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $8 - local.get $2 - call $~lib/array/Array#__get - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $9 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - i32.const 18448 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - i32.const 18452 - local.get $9 - i32.store - i32.const 18448 - local.get $9 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 18448 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=16 - i32.const 18448 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $1 - local.get $9 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end - end - local.get $3 - local.get $6 - i32.add - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/codec/Decoder#u24 (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 3 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - local.get $0 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=4 - i32.const 3 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/Decoder#u32 (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 4 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - local.get $0 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 3 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=4 - i32.const 4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/Decoder#isExhausted (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.le_s - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/decodeSpi (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/codec/Decoder#constructor - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#u24 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#u24 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 2 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $3 - local.get $1 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - drop - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $3 - local.get $1 - i32.load offset=4 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - drop - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $1 - i32.load offset=4 - i32.const 2 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#u24 - drop - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $2 - call $assembly/codec/Decoder#bytes - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $0 - call $assembly/codec/Decoder#bytes - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#u32 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $0 - call $assembly/codec/Decoder#bytes - local.tee $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 18480 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $0 - i32.store offset=8 - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - i32.load offset=4 - i32.sub - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 18480 - local.get $0 - call $~lib/string/String#concat - i32.const 17408 - i32.const 31 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/program/deblob - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner2 - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner2 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/program/liftBytes - local.tee $3 - i32.store offset=4 - i32.const 15424 - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - local.get $2 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - block $__inlined_func$assembly/program/extractCodeAndMetadata$14 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - call $assembly/codec/Decoder#constructor - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/Decoder#varU32 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - call $assembly/codec/Decoder#bytes - local.tee $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.load offset=4 - local.set $7 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $6 - local.get $7 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.load offset=4 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $2 - local.get $6 - call $~lib/typedarray/Uint8Array#get:length - local.get $7 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 37 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $2 - local.get $6 - i32.store - local.get $2 - local.get $6 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $2 - local.get $3 - i32.store offset=4 - local.get $2 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - br $__inlined_func$assembly/program/extractCodeAndMetadata$14 - end - br $folding-inner2 - end - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 17680 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 17680 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 17728 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 17680 - i32.const 17728 - call $~lib/string/String.__concat - local.tee $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - local.tee $8 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 17760 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner2 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 17760 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - i32.load offset=4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $2 - loop $for-loop|0 - local.get $2 - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $4 - local.get $9 - i32.add - i32.load8_u - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - i32.const 4 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $5 - local.get $4 - local.get $8 - i32.const 17760 - i32.load - call_indirect (type $7) - local.tee $0 - i32.store offset=8 - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - local.get $6 - local.get $0 - call $~lib/string/String.__concat - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 17792 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 17792 - call $~lib/string/String.__concat - local.tee $0 - i32.store offset=8 - end - local.get $1 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - call $assembly/program/deblob - local.tee $1 - i32.store offset=36 - br $folding-inner1 - end - local.get $1 - i32.const 1 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - call $assembly/program/decodeSpi - local.tee $1 - i32.store offset=40 - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - i32.const 18608 - i32.store - local.get $1 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - i32.const 18608 - local.get $0 - call $~lib/string/String#concat - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=20 - local.get $1 - call $assembly/api-generic/getAssembly - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - local.get $0 - local.get $1 - call $~lib/string/String.__concat - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-generic/VmInput#constructor (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 47 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 43 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store - local.get $2 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 104 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $2 - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 104 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 13 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - i32.const 1 - global.set $~argumentsLength - block $__inlined_func$~lib/array/Array#fill@varargs$16 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load offset=12 - local.tee $4 - i32.const 0 - local.get $4 - i32.const 0 - i32.le_s - select - local.tee $0 - local.get $4 - local.tee $4 - i32.lt_s - if - local.get $3 - local.get $0 - i32.const 3 - i32.shl - i32.add - i32.const 0 - local.get $4 - local.get $0 - i32.sub - i32.const 3 - i32.shl - memory.fill - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - br $__inlined_func$~lib/array/Array#fill@varargs$16 - end - br $folding-inner1 - end - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 18656 - call $~lib/rt/__newArray - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store offset=16 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 18688 - call $~lib/rt/__newArray - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store offset=20 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 18720 - call $~lib/rt/__newArray - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store offset=24 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory-page/Arena#constructor (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 16 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store - local.get $0 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 524288 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 17 - i32.const 18752 - call $~lib/rt/__newArray - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $0 - local.get $2 - i32.store - local.get $0 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 128 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $4 - i32.store offset=12 - loop $for-loop|0 - local.get $1 - i32.const 128 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $1 - i32.const 12 - i32.shl - local.tee $3 - local.get $4 - i32.const 20 - i32.sub - i32.load offset=16 - local.tee $5 - i32.gt_u - if - i32.const 1504 - i32.const 1744 - i32.const 1860 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.const 4096 - i32.add - local.get $5 - i32.gt_s - if - i32.const 9200 - i32.const 1744 - i32.const 1874 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $5 - i32.store offset=8 - local.get $5 - local.get $4 - i32.store - local.get $5 - local.get $4 - i32.const 0 - call $~lib/rt/itcms/__link - local.get $5 - i32.const 4096 - i32.store offset=8 - local.get $5 - local.get $3 - local.get $4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $1 - local.get $5 - call $assembly/memory-page/RawPage#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $2 - i32.load offset=12 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load offset=4 - local.tee $6 - i32.const 4 - i32.add - local.get $6 - local.get $3 - i32.const 1 - i32.sub - i32.const 2 - i32.shl - memory.copy - local.get $6 - local.get $5 - i32.store - local.get $2 - local.get $5 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory/MemoryBuilder#constructor (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 50 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.const 18 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 16 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.store - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 48 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - call $assembly/memory-page/Arena#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory/MemoryBuilder#setData (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - loop $while-continue|0 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - i32.gt_s - if - local.get $2 - i32.const 12 - i32.shr_u - local.tee $4 - i32.const 16 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - i32.const 18784 - i32.store offset=4 - local.get $4 - i32.const 10 - call $~lib/util/number/utoa32 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 18784 - local.get $0 - call $~lib/string/String#concat - i32.const 18880 - i32.const 67 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $5 - i32.store offset=4 - local.get $5 - local.get $4 - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - call $assembly/memory-page/Arena#acquire - local.tee $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $1 - local.get $5 - call $assembly/memory-page/Page#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $6 - local.get $4 - local.get $5 - call $"~lib/map/Map#set" - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - local.get $4 - call $"~lib/map/Map#get" - local.tee $5 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - i32.const 4096 - local.get $2 - i32.const 4095 - i32.and - local.tee $7 - i32.sub - local.tee $4 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - end - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $5 - i32.store offset=16 - local.get $5 - call $assembly/memory-page/RawPage#get:data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $3 - i32.const 0 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $~lib/typedarray/Uint8Array#get:length - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - local.get $7 - local.get $8 - i32.add - i32.lt_s - if - i32.const 1504 - i32.const 1744 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $7 - local.get $5 - i32.load offset=4 - i32.add - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.load offset=4 - local.get $8 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $3 - i32.store - br $while-continue|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory/MemoryBuilder#build (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 15 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $0 - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $0 - local.get $3 - i32.store offset=8 - local.get $0 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store - local.get $1 - i32.const 12 - i32.shr_u - local.tee $1 - i32.const 16 - i32.lt_u - if - i32.const 18944 - i32.const 18880 - i32.const 104 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $0 - local.get $1 - local.get $1 - i32.const 1 - i32.sub - local.get $3 - local.get $1 - call $"~lib/map/Map#has" - select - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-generic/buildMemory (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - i32.const 65536 - local.set $3 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $4 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - i32.load offset=8 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - i32.load - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $0 - local.get $8 - local.get $7 - local.get $9 - call $assembly/memory/MemoryBuilder#setData - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load offset=8 - i32.const 2 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $3 - local.get $6 - i32.load - i32.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load - local.set $3 - end - end - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|0 - end - end - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - local.get $5 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.tee $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $6 - i32.store offset=20 - i32.const 0 - local.set $4 - loop $for-loop|2 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/typedarray/Uint8Array#get:length - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - local.get $6 - local.get $4 - local.get $7 - local.get $4 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|2 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $0 - i32.const 0 - local.get $1 - local.get $6 - call $assembly/memory/MemoryBuilder#setData - local.get $5 - i32.const 1 - i32.add - local.set $5 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - call $assembly/memory/MemoryBuilder#build - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/interpreter/Interpreter#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 33 - i32.const 29 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store - local.get $3 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=8 - local.get $3 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=12 - local.get $3 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store8 offset=32 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $3 - local.get $0 - i32.store - local.get $3 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - i32.store offset=4 - local.get $3 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $3 - local.get $2 - i32.store offset=8 - local.get $3 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 51 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $3 - local.get $0 - i32.store offset=12 - local.get $3 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const -1 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store8 offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/util/string/joinIntegerArray (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $1 - i32.const 1 - i32.sub - local.tee $4 - i32.const 0 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15424 - return - end - local.get $4 - i32.eqz - if - local.get $0 - i64.load - i32.const 10 - call $~lib/util/number/utoa64 - local.set $0 - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 18412 - i32.load - i32.const 1 - i32.shr_u - local.tee $5 - i32.const 20 - i32.add - local.get $4 - i32.mul - i32.const 20 - i32.add - local.tee $6 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store offset=4 - loop $for-loop|0 - local.get $3 - local.get $4 - i32.lt_s - if - local.get $1 - local.get $2 - i32.const 1 - i32.shl - i32.add - local.get $0 - local.get $3 - i32.const 3 - i32.shl - i32.add - i64.load - call $~lib/util/number/itoa_buffered - local.get $2 - i32.add - local.set $2 - local.get $5 - if - local.get $1 - local.get $2 - i32.const 1 - i32.shl - i32.add - i32.const 18416 - local.get $5 - i32.const 1 - i32.shl - memory.copy - local.get $2 - local.get $5 - i32.add - local.set $2 - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - local.get $6 - local.get $1 - local.get $2 - i32.const 1 - i32.shl - i32.add - local.get $0 - local.get $4 - i32.const 3 - i32.shl - i32.add - i64.load - call $~lib/util/number/itoa_buffered - local.get $2 - i32.add - local.tee $2 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.gt_s - select - local.tee $2 - local.get $1 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - local.tee $1 - local.get $1 - local.get $2 - i32.gt_s - select - local.tee $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.le_s - select - i32.const 1 - i32.shl - local.set $3 - block $__inlined_func$~lib/string/String#substring$2458 - local.get $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.ge_s - select - i32.const 1 - i32.shl - local.tee $2 - local.get $3 - i32.sub - local.tee $4 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15424 - local.set $0 - br $__inlined_func$~lib/string/String#substring$2458 - end - local.get $3 - i32.eqz - local.get $2 - local.get $1 - i32.const 1 - i32.shl - i32.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#substring$2458 - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store offset=4 - local.get $1 - local.get $0 - local.get $3 - i32.add - local.get $4 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - local.set $0 - end - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/staticarray/StaticArray#join (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store - local.get $0 - local.get $1 - call $~lib/util/string/joinIntegerArray - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-generic/runVm~anonymous|0 (param $0 i64) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 17728 - i32.store - local.get $0 - i32.const 16 - call $~lib/util/number/utoa64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 17728 - local.get $1 - call $~lib/string/String#concat - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - local.tee $5 - i32.const 2 - i32.const 52 - i32.const 0 - call $~lib/rt/__newArray - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=4 - local.set $6 - loop $for-loop|0 - local.get $2 - local.get $5 - i32.lt_s - if - local.get $0 - local.get $2 - i32.const 3 - i32.shl - i32.add - i64.load - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 3 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $7 - local.get $2 - local.get $0 - local.get $1 - i32.load - call_indirect (type $12) - local.tee $4 - i32.store offset=8 - local.get $6 - local.get $2 - i32.const 2 - i32.shl - i32.add - local.get $4 - i32.store - local.get $3 - local.get $4 - i32.const 1 - call $~lib/rt/itcms/__link - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/array/Array<~lib/string/String>#join (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store - i32.const 18416 - call $~lib/util/string/joinStringArray - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/resolveArguments (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i64) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner6 - block $folding-inner5 - block $folding-inner4 - block $folding-inner3 - block $folding-inner2 - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - local.get $2 - call $assembly/program/decodeArguments - local.tee $2 - i32.store offset=4 - local.get $2 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.const 54 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - call $~lib/object/Object#constructor - local.tee $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - call $assembly/arguments/Args#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $6 - local.get $1 - i32.store offset=32 - local.get $6 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i32.store offset=32 - local.get $6 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - block $case13|0 - block $case12|0 - block $case11|0 - block $case8|0 - block $case5|0 - block $case4|0 - block $case2|0 - local.get $0 - br_table $folding-inner6 $folding-inner1 $case2|0 $folding-inner1 $case4|0 $case5|0 $folding-inner3 $folding-inner3 $case8|0 $folding-inner4 $folding-inner4 $case11|0 $case12|0 $case13|0 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s - i64.store - br $folding-inner2 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - br $folding-inner2 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - i64.load32_u - i64.const 32 - i64.shl - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $4 - local.get $2 - i64.load32_u offset=4 - i64.add - i64.store offset=8 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=8 - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=12 - i64.store offset=24 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=8 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=16 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - i32.const 19552 - i32.store - local.get $0 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - i32.const 19552 - local.get $0 - call $~lib/string/String#concat - i32.const 19632 - i32.const 347 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s - i64.store - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=4 - i64.store offset=8 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=4 - i64.store offset=8 - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=8 - i64.store offset=16 - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $assembly/interpreter/branch (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 56 - call $~lib/rt/itcms/__new - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - call $~lib/object/Object#constructor - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - block $__inlined_func$assembly/program/BasicBlocks#isStart$2459 - local.get $1 - local.get $2 - i32.add - local.tee $1 - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - i32.const 2 - i32.and - i32.const 0 - i32.ne - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$assembly/program/BasicBlocks#isStart$2459 - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - local.set $0 - end - local.get $0 - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 1 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $1 - i32.store offset=4 - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/interpreter/Interpreter#nextStep (param $0 i32) (result i32) - (local $1 i32) - (local $2 i64) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner6 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner6 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=20 - i32.const 3 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const -1 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=28 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const -1 - i32.store offset=28 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - block $folding-inner5 - local.get $0 - i32.load offset=20 - i32.const -1 - i32.ne - br_if $folding-inner5 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - block $folding-inner4 - local.get $0 - i32.load offset=28 - i32.const -1 - i32.ne - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=28 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const -1 - i32.store offset=28 - br $folding-inner4 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=16 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=4 - local.tee $3 - i32.store - local.get $3 - local.get $1 - call $assembly/program/Mask#isInstruction - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - global.get $assembly/instructions/MISSING_INSTRUCTION - i64.load offset=8 - call $assembly/gas/GasCounter#sub@override - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 4 - i32.store offset=20 - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store offset=20 - end - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load - local.tee $3 - i32.store - local.get $3 - local.get $1 - call $~lib/typedarray/Uint8Array#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length - local.get $3 - i32.gt_s - if (result i32) - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $4 - i32.store - local.get $4 - local.get $3 - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION - end - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $5 - i32.store - block $folding-inner3 - block $folding-inner1 - block $folding-inner0 - local.get $5 - local.get $4 - i64.load offset=8 - call $assembly/gas/GasCounter#sub@override - br_if $folding-inner0 - local.get $4 - global.get $assembly/instructions/MISSING_INSTRUCTION - i32.eq - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $5 - i32.store - local.get $5 - local.get $1 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $8 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load - local.tee $8 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - local.get $8 - local.get $1 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $5 - call $assembly/program/decodeArguments - local.tee $6 - i32.store offset=16 - local.get $4 - global.get $assembly/instructions/SBRK - i32.eq - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u offset=32 - else - i32.const 0 - end - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $4 - i32.const 12 - local.get $6 - i64.load32_u - local.tee $2 - i32.wrap_i64 - local.get $2 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - i64.const 4095 - i64.add - i64.const 12 - i64.shr_u - i64.const 4 - i64.shl - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $4 - i32.store - local.get $4 - local.get $2 - call $assembly/gas/GasCounter#sub@override - br_if $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - i32.const 15264 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15264 - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.tee $3 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $7 - i32.store offset=8 - i32.const 3 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $6 - local.get $4 - local.get $7 - local.get $3 - i32.load - call_indirect (type $0) - local.tee $3 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - block $break|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $3 - i32.load - br_table $case3|0 $case1|0 $case0|0 $case2|0 $break|0 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $__inlined_func$assembly/interpreter/dJump$17 - block $folding-inner11 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner6 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner6 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 55 - call $~lib/rt/itcms/__new - local.tee $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - call $~lib/object/Object#constructor - local.tee $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $3 - i32.const -65536 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - i32.store - br $__inlined_func$assembly/interpreter/dJump$17 - end - local.get $3 - i32.const 1 - i32.and - i32.const 1 - local.get $3 - select - br_if $folding-inner11 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $4 - i32.store offset=4 - local.get $3 - i32.const 1 - i32.shr_u - i32.const 1 - i32.sub - local.tee $3 - local.get $4 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.ge_u - br_if $folding-inner11 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $1 - i32.store offset=4 - local.get $1 - local.get $3 - call $~lib/staticarray/StaticArray#__get - local.tee $2 - i64.const 4294967296 - i64.ge_u - br_if $folding-inner11 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $2 - i64.store32 offset=4 - br $__inlined_func$assembly/interpreter/dJump$17 - end - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 2 - i32.store - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - local.tee $1 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.load - i32.const 1 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - i32.store offset=20 - br $folding-inner4 - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - i32.const 2 - i32.eq - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=12 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $1 - i32.load offset=4 - i32.const 0 - call $assembly/interpreter/branch - local.tee $1 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load8_u - i32.eqz - br_if $folding-inner1 - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load offset=12 - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - local.get $1 - local.get $3 - i32.load offset=4 - call $assembly/interpreter/branch - local.tee $1 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load8_u - i32.eqz - br_if $folding-inner1 - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=12 - i32.const 3 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 3 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $0 - local.get $3 - i32.load offset=16 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=16 - i32.const 1 - i32.add - local.get $5 - i32.add - i32.store offset=28 - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=12 - i32.const 1 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - i64.const 1 - call $assembly/gas/GasCounter#sub@override - drop - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=16 - i32.const 65536 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store offset=20 - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 2 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $0 - local.get $3 - i32.load offset=16 - i32.store offset=24 - end - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=12 - i32.const 2 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - i64.const 1 - call $assembly/gas/GasCounter#sub@override - drop - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=12 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $0 - local.get $3 - i32.load offset=16 - i32.store offset=24 - br $folding-inner5 - end - i32.const 19968 - i32.const 20016 - i32.const 173 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=16 - local.get $5 - i32.const 1 - i32.add - i32.add - i32.store offset=16 - br $folding-inner4 - end - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 4 - i32.store offset=20 - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store offset=20 - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.load offset=4 - i32.store offset=16 - end - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 1 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/array/Array#set:length (param $0 i32) (param $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - local.get $1 - i32.const 2 - i32.const 0 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#push (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $0 - i32.load offset=12 - local.tee $2 - i32.const 1 - i32.add - local.tee $3 - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.load offset=4 - i32.add - local.get $1 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-generic/InitialChunk#constructor (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 45 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 20192 - call $~lib/rt/__newArray - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/array/Array#push (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $0 - i32.load offset=12 - local.tee $2 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $2 - i32.const 2 - i32.shl - i32.add - local.get $1 - i32.store - local.get $0 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-generic/getOutputChunks (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 20160 - call $~lib/rt/__newArray - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.load offset=8 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.load offset=16 - local.set $8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 42 - call $~lib/rt/itcms/__new - local.tee $9 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store - local.get $9 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=12 - local.get $8 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9152 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - local.get $8 - local.get $8 - i32.const 8 - i32.le_u - select - i32.const 2 - i32.shl - local.tee $10 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $9 - local.get $5 - i32.store - local.get $9 - local.get $5 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $10 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $8 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - loop $for-loop|0 - local.get $2 - local.get $8 - i32.lt_s - if - local.get $7 - local.get $2 - i32.const 12 - i32.mul - i32.add - local.tee $5 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $1 - local.get $5 - i32.load - call $~lib/array/Array#__set - local.get $1 - i32.const 1 - i32.add - local.set $1 - end - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $1 - call $~lib/array/Array#set:length - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - i32.const 0 - local.set $1 - loop $for-loop|00 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/array/Array#get:length - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $4 - call $~lib/array/Array#__get - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $5 - call $"~lib/map/Map#get" - local.tee $6 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $2 - i32.store offset=4 - local.get $2 - i32.load offset=4 - if - i32.const 0 - local.set $2 - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - local.get $7 - call $assembly/memory-page/RawPage#get:data - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - local.get $7 - call $assembly/memory-page/RawPage#get:data - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $2 - call $~lib/typedarray/Uint8Array#__get - local.tee $7 - if - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $8 - i32.store offset=4 - local.get $8 - local.get $7 - call $~lib/array/Array#push - else - global.get $~lib/memory/__stack_pointer - call $assembly/api-generic/InitialChunk#constructor - local.tee $1 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $5 - i32.const 12 - i32.shl - local.get $2 - i32.add - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 1 - i32.const 0 - i32.const 27 - i32.const 0 - call $~lib/rt/__newArray - local.tee $8 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.load offset=12 - i32.eqz - if - local.get $8 - i32.const 1 - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - i32.store offset=12 - end - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.load offset=4 - local.get $7 - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $1 - local.get $8 - i32.store offset=4 - local.get $1 - local.get $8 - i32.const 0 - call $~lib/rt/itcms/__link - end - else - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - call $~lib/array/Array#push - i32.const 0 - local.set $1 - end - end - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end - end - end - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|00 - end - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - call $~lib/array/Array#push - end - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $"~lib/map/Map#values" (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=16 - local.set $2 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 57 - call $~lib/rt/itcms/__new - local.tee $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - i32.store - local.get $6 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - i32.store offset=12 - local.get $2 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9152 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - local.get $2 - local.get $2 - i32.const 8 - i32.le_u - select - i32.const 2 - i32.shl - local.tee $0 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $6 - local.get $5 - i32.store - local.get $6 - local.get $5 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - loop $for-loop|0 - local.get $2 - local.get $3 - i32.gt_s - if - local.get $4 - local.get $3 - i32.const 12 - i32.mul - i32.add - local.tee $5 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $1 - local.tee $0 - i32.const 1 - i32.add - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $0 - local.get $6 - i32.load offset=12 - i32.ge_u - if - local.get $0 - i32.const 0 - i32.lt_s - if - i32.const 1504 - i32.const 9152 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $6 - local.get $0 - i32.const 1 - i32.add - local.tee $5 - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $5 - i32.store offset=12 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load offset=4 - local.get $0 - i32.const 2 - i32.shl - i32.add - local.get $7 - i32.store - local.get $6 - local.get $7 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $1 - call $~lib/array/Array#set:length - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-generic/runVm (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i64) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $14 i32) - (local $15 i32) - (local $16 i32) - (local $17 i32) - global.get $~lib/memory/__stack_pointer - i32.const 124 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 124 - memory.fill - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=16 - local.tee $7 - i32.store offset=4 - local.get $7 - call $assembly/program/liftBytes - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $assembly/program/deblob - local.tee $10 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 13 - call $~lib/staticarray/StaticArray#constructor - local.tee $6 - i32.store offset=16 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $3 - local.get $6 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $3 - local.get $7 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - i32.load offset=4 - local.get $3 - i32.const 3 - i32.shl - i32.add - i64.load - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - local.get $3 - local.get $5 - call $~lib/staticarray/StaticArray#__set - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - call $assembly/memory/MemoryBuilder#constructor - local.tee $3 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=20 - local.tee $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=24 - local.tee $8 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $7 - local.get $8 - call $assembly/api-generic/buildMemory - local.tee $3 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $10 - local.get $6 - local.get $3 - call $assembly/interpreter/Interpreter#constructor - local.tee $11 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $2 - i32.store8 offset=32 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $11 - local.get $0 - i32.load offset=4 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=12 - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i64.load offset=8 - call $assembly/gas/GasCounter#set@override - i32.const 1 - local.set $0 - loop $for-loop|1 - block $for-break1 - local.get $0 - i32.eqz - if - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - call $~lib/staticarray/StaticArray#join - local.tee $0 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - i32.const 19152 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19156 - local.get $0 - i32.store - i32.const 19152 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19152 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - i32.const 19152 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 19216 - i32.store offset=40 - local.get $6 - i32.const 19216 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store offset=8 - local.get $2 - call $~lib/array/Array<~lib/string/String>#join - local.tee $0 - i32.store offset=44 - global.get $~lib/memory/__stack_pointer - i32.const 19184 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19188 - local.get $0 - i32.store - i32.const 19184 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19184 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - i32.const 19184 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 19248 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - local.get $11 - i32.load offset=20 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19248 - local.get $0 - call $~lib/string/String#concat - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - br $for-break1 - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 19312 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - local.get $11 - i32.load offset=16 - i32.const 10 - call $~lib/util/number/utoa32 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19312 - local.get $0 - call $~lib/string/String#concat - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 19344 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - local.get $11 - i32.load offset=20 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19344 - local.get $0 - call $~lib/string/String#concat - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 19056 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store offset=40 - local.get $6 - call $~lib/staticarray/StaticArray#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19056 - local.get $0 - call $~lib/string/String#concat - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 19056 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=48 - global.get $~lib/memory/__stack_pointer - i32.const 19392 - i32.store offset=52 - local.get $6 - i32.const 19392 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store offset=40 - local.get $0 - call $~lib/array/Array<~lib/string/String>#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19056 - local.get $0 - call $~lib/string/String#concat - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.load offset=16 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $2 - i32.store - local.get $2 - call $~lib/typedarray/Uint8Array#get:length - local.get $0 - i32.gt_u - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $0 - local.get $11 - i32.load offset=16 - call $~lib/typedarray/Uint8Array#__get - else - i32.const 0 - end - local.set $0 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $2 - i32.store - local.get $0 - local.get $2 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $2 - i32.store - local.get $2 - local.get $0 - call $~lib/array/Array#__get - end - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.load offset=4 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $3 - local.get $11 - i32.load offset=16 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $7 - i32.store offset=56 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=60 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 255 - i32.and - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $0 - i32.store offset=64 - global.get $~lib/memory/__stack_pointer - i32.const 19504 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - i32.const 19508 - local.get $7 - i32.store - i32.const 19504 - local.get $7 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19504 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19516 - local.get $0 - i32.store - i32.const 19504 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19504 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - i32.const 19504 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load - local.tee $7 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.load - local.tee $7 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - local.get $11 - i32.load offset=16 - i32.const 1 - i32.add - local.set $8 - i32.const 1 - global.set $~argumentsLength - local.get $7 - local.get $8 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=4 - local.tee $8 - i32.store offset=4 - local.get $7 - local.get $3 - local.get $8 - call $assembly/program/resolveArguments - local.tee $12 - i32.store offset=68 - local.get $12 - if - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load - call $~lib/util/number/itoa64 - local.tee $0 - i32.store offset=72 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.load offset=32 - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $2 - i32.store offset=76 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $3 - i32.store offset=80 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=8 - call $~lib/util/number/itoa64 - local.tee $7 - i32.store offset=84 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.load offset=32 - local.tee $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load offset=4 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $8 - i32.store offset=88 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=8 - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $13 - i32.store offset=92 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=16 - call $~lib/util/number/itoa64 - local.tee $14 - i32.store offset=96 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.load offset=32 - local.tee $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.load offset=8 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $9 - i32.store offset=100 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=16 - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $15 - i32.store offset=104 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=24 - call $~lib/util/number/itoa64 - local.tee $16 - i32.store offset=108 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.load offset=32 - local.tee $17 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.load offset=12 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $17 - i32.store offset=112 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=24 - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $12 - i32.store offset=116 - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19844 - local.get $0 - i32.store - i32.const 19840 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 19852 - local.get $2 - i32.store - i32.const 19840 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - i32.const 19860 - local.get $3 - i32.store - i32.const 19840 - local.get $3 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - i32.const 19868 - local.get $7 - i32.store - i32.const 19840 - local.get $7 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - i32.const 19876 - local.get $8 - i32.store - i32.const 19840 - local.get $8 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - i32.const 19884 - local.get $13 - i32.store - i32.const 19840 - local.get $13 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - i32.const 19892 - local.get $14 - i32.store - i32.const 19840 - local.get $14 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - i32.const 19900 - local.get $9 - i32.store - i32.const 19840 - local.get $9 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store offset=8 - i32.const 19908 - local.get $15 - i32.store - i32.const 19840 - local.get $15 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - i32.const 19916 - local.get $16 - i32.store - i32.const 19840 - local.get $16 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=8 - i32.const 19924 - local.get $17 - i32.store - i32.const 19840 - local.get $17 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - i32.const 19932 - local.get $12 - i32.store - i32.const 19840 - local.get $12 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - i32.const 19840 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - end - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $assembly/interpreter/Interpreter#nextStep - local.set $0 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 44 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - call $~lib/object/Object#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const -1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 0 - i32.const 3 - i32.const 43 - i32.const 20096 - call $~lib/rt/__newArray - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.store offset=4 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 20128 - call $~lib/rt/__newArray - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=120 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $1 - local.get $11 - i32.load offset=20 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=4 - local.tee $0 - i32.store offset=8 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.tee $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.gt_s - select - local.tee $2 - i32.const 3 - i32.const 43 - i32.const 0 - call $~lib/rt/__newArray - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=4 - local.get $0 - local.get $2 - i32.const 3 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $1 - local.get $3 - i32.store offset=4 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $1 - local.get $11 - i32.load offset=16 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=12 - local.tee $0 - i32.store offset=4 - local.get $1 - local.get $0 - call $assembly/gas/GasCounter#get@override - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=8 - local.tee $0 - i32.store offset=8 - local.get $0 - call $assembly/api-generic/getOutputChunks - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=12 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $1 - local.get $11 - i32.load offset=24 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=8 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - call $"~lib/map/Map#values" - local.tee $2 - i32.store offset=8 - loop $for-loop|01 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $2 - local.get $4 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $3 - local.get $6 - call $~lib/array/Array#push - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|01 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 16 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.store - local.get $0 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 48 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.store offset=8 - local.get $0 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 4 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 124 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/program-build/skipBytes (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $folding-inner3 (result i32) - block $folding-inner2 - block $folding-inner1 - block $folding-inner0 - block $case13|0 - block $case12|0 - block $case11|0 - block $case8|0 - block $case7|0 - block $case6|0 - block $case5|0 - block $case4|0 - block $case2|0 - block $case0|0 - local.get $0 - br_table $case0|0 $folding-inner0 $case2|0 $folding-inner0 $case4|0 $case5|0 $case6|0 $case7|0 $case8|0 $folding-inner2 $folding-inner2 $case11|0 $case12|0 $case13|0 - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u - i32.const 1 - i32.add - local.tee $0 - i32.const 255 - i32.and - i32.const 1 - i32.add - block $__inlined_func$assembly/program-build/immBytes$2177 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $1 - local.get $0 - i32.const 1 - i32.add - i32.const 255 - i32.and - local.tee $0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$2177 - drop - local.get $1 - local.get $0 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - i32.add - br $folding-inner3 - end - block $__inlined_func$assembly/program-build/immBytes$2179 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $0 - i32.const 0 - i32.le_s - br_if $__inlined_func$assembly/program-build/immBytes$2179 - drop - local.get $0 - i32.const 1 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - i32.const 1 - i32.add - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 9 - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=8 - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=12 - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 1 - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u - i32.const 1 - i32.add - local.tee $0 - i32.const 255 - i32.and - i32.const 2 - i32.add - block $__inlined_func$assembly/program-build/immBytes$2185 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $1 - local.get $0 - i32.const 255 - i32.and - i32.const 2 - i32.add - local.tee $0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$2185 - drop - local.get $1 - local.get $0 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - i32.add - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 2 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 19552 - i32.store - local.get $0 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - i32.const 19552 - local.get $0 - call $~lib/string/String#concat - i32.const 20368 - i32.const 73 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - block $__inlined_func$assembly/program-build/immBytes$2175 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $0 - i32.const 0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$2175 - drop - local.get $0 - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u offset=1 - i32.const 1 - i32.add - local.tee $0 - i32.const 255 - i32.and - i32.const 1 - i32.add - block $__inlined_func$assembly/program-build/immBytes$2181 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $1 - local.get $0 - i32.const 255 - i32.and - i32.const 1 - i32.add - local.tee $0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$2181 - drop - local.get $1 - local.get $0 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - i32.add - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - i32.const 1 - i32.add - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program-build/buildMask (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $3 - i32.const 1073741820 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.const 58 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $2 - call $~lib/typedarray/Uint8Array#__get - local.set $1 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length - local.get $1 - i32.gt_s - if (result i32) - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $4 - i32.store - local.get $4 - local.get $1 - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION - end - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $2 - i32.const 1 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 1264 - i32.store - i32.const 1264 - local.get $1 - i32.load offset=4 - call $~lib/array/Array#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $4 - local.get $2 - i32.const 1 - i32.add - local.tee $4 - i32.add - i32.ge_s - if (result i32) - local.get $1 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 1 - global.set $~argumentsLength - local.get $0 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/program-build/skipBytes - local.get $2 - i32.add - else - local.get $2 - end - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 20448 - call $~lib/rt/__newArray - local.tee $4 - i32.store offset=12 - i32.const 0 - local.set $0 - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $0 - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - i32.lt_s - if - i32.const 0 - local.set $2 - local.get $0 - local.set $1 - loop $for-loop|3 - local.get $1 - local.get $0 - i32.const 8 - i32.add - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $2 - i32.const 255 - i32.and - i32.const 1 - i32.shr_u - local.tee $2 - i32.const 128 - i32.or - local.get $2 - local.get $1 - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - i32.lt_s - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $1 - call $~lib/staticarray/StaticArray#__get - else - i32.const 0 - end - select - local.set $2 - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|3 - end - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $2 - call $~lib/array/Array#push - local.get $0 - i32.const 8 - i32.add - local.set $0 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/codec/encodeVarU32 (param $0 i64) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i64) - (local $5 i32) - (local $6 i64) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner2 - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner2 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - local.get $0 - i64.eqz - if - i32.const 1 - call $~lib/typedarray/Uint8Array#constructor - local.set $3 - br $folding-inner1 - end - local.get $0 - i64.const 72057594037927936 - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - i32.const 9 - call $~lib/typedarray/Uint8Array#constructor - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.const 255 - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $3 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/dataview/DataView#constructor@varargs$38 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 59 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store - local.get $1 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - local.get $5 - i32.lt_u - local.get $5 - i32.const 1073741820 - i32.gt_u - i32.or - if - i32.const 9200 - i32.const 20480 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $1 - local.get $3 - i32.store - local.get $1 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - br $__inlined_func$~lib/dataview/DataView#constructor@varargs$38 - end - br $folding-inner2 - end - local.tee $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner2 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load offset=8 - i32.const 9 - i32.lt_s - if - i32.const 1504 - i32.const 20480 - i32.const 174 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load offset=4 - local.get $0 - i64.store offset=1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i64.const 562949953421312 - local.set $4 - i32.const 7 - local.set $1 - loop $for-loop|0 - local.get $1 - i32.const 0 - i32.ge_s - if - local.get $0 - local.get $4 - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $3 - i32.store offset=16 - i32.const 256 - i32.const 1 - i32.const 8 - local.get $1 - i32.sub - local.tee $2 - i32.shl - i32.const 0 - local.get $2 - i32.const 32 - i32.lt_u - select - i32.sub - i64.extend_i32_s - local.get $0 - i32.const 1 - local.get $1 - i32.const 3 - i32.shl - local.tee $2 - i32.shl - i32.const 0 - local.get $2 - i32.const 32 - i32.lt_u - select - i64.extend_i32_s - local.tee $4 - i64.div_u - i64.add - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - local.get $6 - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $0 - local.get $4 - i64.rem_u - local.set $0 - i32.const 1 - local.set $2 - loop $for-loop|1 - local.get $2 - local.get $1 - i32.const 1 - i32.add - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $2 - local.get $0 - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $0 - i64.const 8 - i64.shr_u - local.set $0 - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end - end - br $folding-inner1 - end - local.get $4 - i64.const 7 - i64.shr_u - local.set $4 - local.get $1 - i32.const 1 - i32.sub - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20544 - i32.store offset=4 - local.get $0 - i32.const 10 - call $~lib/util/number/utoa64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - i32.const 20544 - local.get $1 - call $~lib/string/String#concat - i32.const 17408 - i32.const 160 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api/fillRegisters (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -8 - i32.and - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length - local.get $3 - i32.ne - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - call $~lib/array/Array#get:length - call $~lib/number/I32#toString - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - call $~lib/number/I32#toString - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 20768 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - i32.const 20772 - local.get $0 - i32.store - i32.const 20768 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 20768 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - i32.const 20780 - local.get $1 - i32.store - i32.const 20768 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 20768 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=12 - i32.const 20768 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 20816 - i32.const 166 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.lt_s - if - i64.const 0 - local.set $4 - i32.const 0 - local.set $3 - loop $for-loop|1 - local.get $3 - i32.const 8 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $4 - local.get $1 - local.get $2 - i32.const 3 - i32.shl - local.get $3 - i32.add - call $~lib/array/Array#__get - i64.extend_i32_u - local.get $3 - i32.const 3 - i32.shl - i32.const 255 - i32.and - i64.extend_i32_u - i64.shl - i64.or - local.set $4 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $2 - local.get $4 - call $~lib/staticarray/StaticArray#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $assembly/program/liftBytes - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/program/deblob - local.tee $7 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 13 - call $~lib/staticarray/StaticArray#constructor - local.tee $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $5 - local.get $1 - call $assembly/api/fillRegisters - global.get $~lib/memory/__stack_pointer - call $assembly/memory/MemoryBuilder#constructor - local.tee $8 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=24 - block $__inlined_func$assembly/api/readPages$43 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 20880 - call $~lib/rt/__newArray - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - call $assembly/codec/Decoder#constructor - local.tee $2 - i32.store offset=8 - loop $while-continue|0 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 48 - call $~lib/rt/itcms/__new - local.tee $9 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - call $~lib/object/Object#constructor - local.tee $9 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $9 - local.get $2 - call $assembly/codec/Decoder#u32 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $9 - local.get $2 - call $assembly/codec/Decoder#u32 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $9 - i32.const 2 - i32.const 1 - local.get $2 - call $assembly/codec/Decoder#u8 - select - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $1 - local.get $9 - call $~lib/array/Array#push - br $while-continue|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - br $__inlined_func$assembly/api/readPages$43 - end - br $folding-inner1 - end - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 20912 - call $~lib/rt/__newArray - local.tee $10 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - call $assembly/codec/Decoder#constructor - local.tee $1 - i32.store offset=8 - loop $while-continue|01 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - call $assembly/api-generic/InitialChunk#constructor - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - local.get $2 - local.get $1 - call $assembly/codec/Decoder#u32 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $assembly/codec/Decoder#u32 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $11 - call $assembly/codec/Decoder#bytes - local.tee $6 - i32.store offset=20 - i32.const 0 - local.set $3 - loop $for-loop|1 - local.get $3 - local.get $11 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - local.tee $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=16 - local.get $12 - local.get $6 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#push - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $10 - local.get $2 - call $~lib/array/Array#push - br $while-continue|01 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $8 - local.get $9 - local.get $10 - call $assembly/api-generic/buildMemory - local.tee $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $7 - local.get $5 - local.get $0 - call $assembly/interpreter/Interpreter#constructor - local.tee $0 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - local.get $4 - call $assembly/gas/GasCounter#set@override - local.get $0 - global.set $assembly/api/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api/nextStep (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 43 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - call $assembly/interpreter/Interpreter#nextStep - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $assembly/api/nSteps (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 51 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=4 - i32.const 1 - local.set $2 - loop $for-loop|0 - local.get $0 - local.get $3 - i32.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/interpreter/Interpreter#nextStep - local.tee $2 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $assembly/api/getProgramCounter (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 68 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/setNextProgramCounter (param $0 i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 76 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/getStatus (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 1 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 84 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=20 - i32.const 255 - i32.and - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/getExitArg (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 92 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=24 - local.tee $0 - i32.eqz - if - i32.const 0 - local.set $0 - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/api/getGasLeft (result i64) - (local $0 i32) - (local $1 i64) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - i64.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 100 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $0 - i32.store offset=8 - local.get $0 - call $assembly/gas/GasCounter#get@override - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/setGasLeft (param $0 i64) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 106 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=12 - local.tee $1 - i32.store offset=8 - local.get $1 - local.get $0 - call $assembly/gas/GasCounter#set@override - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/getRegisters (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i64) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 104 - call $~lib/typedarray/Uint8Array#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - i32.const 1 - global.set $~argumentsLength - local.get $3 - call $~lib/typedarray/Uint8Array#fill@varargs - local.tee $4 - i32.store offset=4 - global.get $assembly/api/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 117 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.store offset=12 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=4 - local.tee $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - local.set $2 - i32.const 0 - local.set $0 - loop $for-loop|1 - local.get $0 - i32.const 8 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $1 - i32.const 3 - i32.shl - local.get $0 - i32.add - local.get $2 - i64.const 255 - i64.and - i32.wrap_i64 - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i64.const 8 - i64.shr_u - local.set $2 - local.get $0 - i32.const 1 - i32.add - local.set $0 - br $for-loop|1 - end - end - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/api/getPageDump (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $assembly/api/interpreter - i32.eqz - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 142 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.tee $1 - i32.store - block $__inlined_func$assembly/memory/Memory#pageDump$2440 - local.get $1 - local.get $0 - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - local.set $0 - br $__inlined_func$assembly/memory/Memory#pageDump$2440 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.tee $1 - i32.store offset=8 - local.get $1 - local.get $0 - call $"~lib/map/Map#get" - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - call $assembly/memory-page/RawPage#get:data - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - end - local.get $0 - i32.store offset=16 - local.get $0 - i32.eqz - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - i32.const 4096 - call $~lib/typedarray/Uint8Array#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 1 - global.set $~argumentsLength - local.get $0 - call $~lib/typedarray/Uint8Array#fill@varargs - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/object/Object#constructor (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/rt/__newArray (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.shl - local.tee $5 - i32.const 1 - call $~lib/rt/itcms/__new - local.set $1 - local.get $3 - if - local.get $1 - local.get $3 - local.get $5 - memory.copy - end - local.get $1 - i32.store - i32.const 16 - local.get $2 - call $~lib/rt/itcms/__new - local.tee $2 - local.get $1 - i32.store - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - local.get $2 - local.get $1 - i32.store offset=4 - local.get $2 - local.get $5 - i32.store offset=8 - local.get $2 - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/staticarray/StaticArray#constructor (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i32.const 1073741820 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 23 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/arraybuffer/ArrayBuffer#constructor (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i32.const 1073741820 - i32.gt_u - if - i32.const 9200 - i32.const 9248 - i32.const 52 - i32.const 43 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/util/number/utoa32 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $1 - i32.const 2 - i32.lt_s - local.get $1 - i32.const 36 - i32.gt_s - i32.or - if - i32.const 15632 - i32.const 15760 - i32.const 350 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15824 - return - end - local.get $1 - i32.const 10 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 100000 - i32.lt_u - if (result i32) - local.get $0 - i32.const 100 - i32.lt_u - if (result i32) - local.get $0 - i32.const 10 - i32.ge_u - i32.const 1 - i32.add - else - local.get $0 - i32.const 10000 - i32.ge_u - i32.const 3 - i32.add - local.get $0 - i32.const 1000 - i32.ge_u - i32.add - end - else - local.get $0 - i32.const 10000000 - i32.lt_u - if (result i32) - local.get $0 - i32.const 1000000 - i32.ge_u - i32.const 6 - i32.add - else - local.get $0 - i32.const 1000000000 - i32.ge_u - i32.const 8 - i32.add - local.get $0 - i32.const 100000000 - i32.ge_u - i32.add - end - end - local.tee $1 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - local.get $2 - local.get $0 - local.get $1 - call $~lib/util/number/utoa32_dec_lut - else - local.get $1 - i32.const 16 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 31 - local.get $0 - i32.clz - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.tee $1 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - local.get $0 - i64.extend_i32_u - local.set $3 - loop $while-continue|0 - local.get $1 - i32.const 2 - i32.ge_u - if - local.get $2 - local.get $1 - i32.const 2 - i32.sub - local.tee $1 - i32.const 1 - i32.shl - i32.add - local.get $3 - i32.wrap_i64 - i32.const 255 - i32.and - i32.const 2 - i32.shl - i32.const 16256 - i32.add - i32.load - i32.store - local.get $3 - i64.const 8 - i64.shr_u - local.set $3 - br $while-continue|0 - end - end - local.get $1 - i32.const 1 - i32.and - if - local.get $2 - local.get $3 - i32.wrap_i64 - i32.const 6 - i32.shl - i32.const 16256 - i32.add - i32.load16_u - i32.store16 - end - else - global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2258 (result i32) - local.get $0 - i64.extend_i32_u - local.set $4 - local.get $1 - i32.popcnt - i32.const 1 - i32.eq - if - i32.const 63 - local.get $4 - i64.clz - i32.wrap_i64 - i32.sub - i32.const 31 - local.get $1 - i32.clz - i32.sub - i32.div_u - i32.const 1 - i32.add - br $__inlined_func$~lib/util/number/ulog_base$2258 - end - local.get $1 - i64.extend_i32_s - local.tee $5 - local.set $3 - i32.const 1 - local.set $2 - loop $while-continue|01 - local.get $3 - local.get $4 - i64.le_u - if - local.get $4 - local.get $3 - i64.div_u - local.set $4 - local.get $3 - local.get $3 - i64.mul - local.set $3 - local.get $2 - i32.const 1 - i32.shl - local.set $2 - br $while-continue|01 - end - end - loop $while-continue|1 - local.get $4 - i64.const 0 - i64.ne - if - local.get $4 - local.get $5 - i64.div_u - local.set $4 - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $while-continue|1 - end - end - local.get $2 - i32.const 1 - i32.sub - end - local.tee $6 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - local.get $2 - local.get $0 - i64.extend_i32_u - local.get $6 - local.get $1 - call $~lib/util/number/utoa64_any_core - end - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/staticarray/StaticArray#constructor (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i32.const 134217727 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 3 - i32.shl - i32.const 14 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/util/number/utoa64 (param $0 i64) (param $1 i32) (result i32) - (local $2 i64) - (local $3 i32) - (local $4 i64) - (local $5 i64) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $1 - i32.const 2 - i32.lt_s - local.get $1 - i32.const 36 - i32.gt_s - i32.or - if - i32.const 15632 - i32.const 15760 - i32.const 401 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i64.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15824 - return - end - local.get $1 - i32.const 10 - i32.eq - if - local.get $0 - i64.const 4294967295 - i64.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.wrap_i64 - local.tee $1 - i32.const 100000 - i32.lt_u - if (result i32) - local.get $1 - i32.const 100 - i32.lt_u - if (result i32) - local.get $1 - i32.const 10 - i32.ge_u - i32.const 1 - i32.add - else - local.get $1 - i32.const 10000 - i32.ge_u - i32.const 3 - i32.add - local.get $1 - i32.const 1000 - i32.ge_u - i32.add - end - else - local.get $1 - i32.const 10000000 - i32.lt_u - if (result i32) - local.get $1 - i32.const 1000000 - i32.ge_u - i32.const 6 - i32.add - else - local.get $1 - i32.const 1000000000 - i32.ge_u - i32.const 8 - i32.add - local.get $1 - i32.const 100000000 - i32.ge_u - i32.add - end - end - local.tee $6 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - local.get $3 - local.get $1 - local.get $6 - call $~lib/util/number/utoa32_dec_lut - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i64.const 1000000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 1000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 100000000000 - i64.ge_u - i32.const 10 - i32.add - local.get $0 - i64.const 10000000000 - i64.ge_u - i32.add - else - local.get $0 - i64.const 100000000000000 - i64.ge_u - i32.const 13 - i32.add - local.get $0 - i64.const 10000000000000 - i64.ge_u - i32.add - end - else - local.get $0 - i64.const 100000000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 10000000000000000 - i64.ge_u - i32.const 16 - i32.add - else - local.get $0 - i64.const -8446744073709551616 - i64.ge_u - i32.const 18 - i32.add - local.get $0 - i64.const 1000000000000000000 - i64.ge_u - i32.add - end - end - local.tee $1 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - local.get $3 - local.get $0 - local.get $1 - call $~lib/util/number/utoa64_dec_lut - end - else - local.get $1 - i32.const 16 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 63 - local.get $0 - i64.clz - i32.wrap_i64 - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.tee $1 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - loop $while-continue|0 - local.get $1 - i32.const 2 - i32.ge_u - if - local.get $3 - local.get $1 - i32.const 2 - i32.sub - local.tee $1 - i32.const 1 - i32.shl - i32.add - local.get $0 - i32.wrap_i64 - i32.const 255 - i32.and - i32.const 2 - i32.shl - i32.const 16256 - i32.add - i32.load - i32.store - local.get $0 - i64.const 8 - i64.shr_u - local.set $0 - br $while-continue|0 - end - end - local.get $1 - i32.const 1 - i32.and - if - local.get $3 - local.get $0 - i32.wrap_i64 - i32.const 6 - i32.shl - i32.const 16256 - i32.add - i32.load16_u - i32.store16 - end - else - global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2264 (result i32) - local.get $0 - local.set $2 - local.get $1 - i32.popcnt - i32.const 1 - i32.eq - if - i32.const 63 - local.get $0 - i64.clz - i32.wrap_i64 - i32.sub - i32.const 31 - local.get $1 - i32.clz - i32.sub - i32.div_u - i32.const 1 - i32.add - br $__inlined_func$~lib/util/number/ulog_base$2264 - end - local.get $1 - i64.extend_i32_s - local.tee $5 - local.set $4 - i32.const 1 - local.set $3 - loop $while-continue|01 - local.get $2 - local.get $4 - i64.ge_u - if - local.get $2 - local.get $4 - i64.div_u - local.set $2 - local.get $4 - local.get $4 - i64.mul - local.set $4 - local.get $3 - i32.const 1 - i32.shl - local.set $3 - br $while-continue|01 - end - end - loop $while-continue|1 - local.get $2 - i64.const 0 - i64.ne - if - local.get $2 - local.get $5 - i64.div_u - local.set $2 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $while-continue|1 - end - end - local.get $3 - i32.const 1 - i32.sub - end - local.tee $6 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - local.get $3 - local.get $0 - local.get $6 - local.get $1 - call $~lib/util/number/utoa64_any_core - end - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/util/number/itoa64 (param $0 i64) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i64.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15824 - return - end - i64.const 0 - local.get $0 - i64.sub - local.get $0 - local.get $0 - i64.const 63 - i64.shr_u - i32.wrap_i64 - i32.const 1 - i32.shl - local.tee $1 - select - local.tee $0 - i64.const 4294967295 - i64.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.wrap_i64 - local.tee $4 - i32.const 100000 - i32.lt_u - if (result i32) - local.get $4 - i32.const 100 - i32.lt_u - if (result i32) - local.get $4 - i32.const 10 - i32.ge_u - i32.const 1 - i32.add - else - local.get $4 - i32.const 10000 - i32.ge_u - i32.const 3 - i32.add - local.get $4 - i32.const 1000 - i32.ge_u - i32.add - end - else - local.get $4 - i32.const 10000000 - i32.lt_u - if (result i32) - local.get $4 - i32.const 1000000 - i32.ge_u - i32.const 6 - i32.add - else - local.get $4 - i32.const 1000000000 - i32.ge_u - i32.const 8 - i32.add - local.get $4 - i32.const 100000000 - i32.ge_u - i32.add - end - end - local.tee $3 - i32.const 1 - i32.shl - local.get $1 - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - local.get $1 - local.get $2 - i32.add - local.get $4 - local.get $3 - call $~lib/util/number/utoa32_dec_lut - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i64.const 1000000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 1000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 100000000000 - i64.ge_u - i32.const 10 - i32.add - local.get $0 - i64.const 10000000000 - i64.ge_u - i32.add - else - local.get $0 - i64.const 100000000000000 - i64.ge_u - i32.const 13 - i32.add - local.get $0 - i64.const 10000000000000 - i64.ge_u - i32.add - end - else - local.get $0 - i64.const 100000000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 10000000000000000 - i64.ge_u - i32.const 16 - i32.add - else - local.get $0 - i64.const -8446744073709551616 - i64.ge_u - i32.const 18 - i32.add - local.get $0 - i64.const 1000000000000000000 - i64.ge_u - i32.add - end - end - local.tee $3 - i32.const 1 - i32.shl - local.get $1 - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - local.get $1 - local.get $2 - i32.add - local.get $0 - local.get $3 - call $~lib/util/number/utoa64_dec_lut - end - local.get $1 - if - local.get $2 - i32.const 45 - i32.store16 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $export:assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - call $assembly/index/disassemble - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/index/runProgram (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $__inlined_func$assembly/index/runProgram$2441 - local.get $2 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - call $assembly/api-generic/VmInput#constructor - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $2 - local.get $1 - i32.store - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i64.const 10000 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $2 - local.get $0 - i32.store offset=16 - local.get $2 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.const 1 - i32.const 0 - call $assembly/api-generic/runVm - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 19248 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - local.get $0 - i32.load - call $~lib/number/I32#toString - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - i32.const 19248 - local.get $1 - call $~lib/string/String#concat - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$assembly/index/runProgram$2441 - end - local.get $2 - i32.const 1 - i32.eq - if - i32.const 20224 - i32.const 20304 - i32.const 57 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 18608 - i32.store offset=4 - local.get $2 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 18608 - local.get $0 - call $~lib/string/String#concat - i32.const 20304 - i32.const 60 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api-generic/runVm@varargs (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $1 - end - i32.const 0 - local.set $2 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - call $assembly/api-generic/runVm - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api-generic/getAssembly (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/api-generic/getAssembly - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/program-build/buildMask - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i64.extend_i32_s - call $assembly/codec/encodeVarU32 - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - i32.const 2 - i32.add - local.get $2 - i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - local.get $2 - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set - i32.const 2 - local.set $2 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $6 - local.get $2 - local.get $5 - local.get $4 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|0 - end - end - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - local.get $6 - local.get $2 - local.get $0 - local.get $1 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|1 - end - end - i32.const 0 - local.set $0 - loop $for-loop|2 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - local.get $0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $6 - local.get $2 - local.get $3 - local.get $0 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - local.get $0 - i32.const 1 - i32.add - local.set $0 - br $for-loop|2 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api/resetGeneric (param $0 i32) (param $1 i32) (param $2 i64) - (local $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $assembly/program/liftBytes - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/program/deblob - local.tee $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 13 - call $~lib/staticarray/StaticArray#constructor - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - call $assembly/api/fillRegisters - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 2 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - call $assembly/memory/MemoryBuilder#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - call $assembly/memory/MemoryBuilder#build - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - local.get $3 - local.get $0 - local.get $1 - call $assembly/interpreter/Interpreter#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - local.get $2 - call $assembly/gas/GasCounter#set@override - local.get $0 - global.set $assembly/api/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $0 - local.get $1 - local.get $2 - local.get $3 - local.get $4 - call $assembly/api/resetGenericWithMemory - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api/setRegisters (param $0 i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $assembly/api/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 134 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $1 - local.get $0 - call $assembly/api/fillRegisters - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api/setMemory (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 155 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $0 - i32.add - local.set $4 - local.get $0 - local.set $2 - loop $for-loop|0 - local.get $2 - local.get $4 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $5 - local.get $2 - local.get $1 - local.get $2 - local.get $0 - i32.sub - call $~lib/typedarray/Uint8Array#__get - call $assembly/memory/Memory#setU8 - drop - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) -) diff --git a/dist/test.d.ts b/dist/test.d.ts deleted file mode 100644 index 981d658..0000000 --- a/dist/test.d.ts +++ /dev/null @@ -1,6 +0,0 @@ -/** Exported memory */ -export declare const memory: WebAssembly.Memory; -/** - * assembly/test-run/runAllTests - */ -export declare function runAllTests(): void; diff --git a/dist/test.js b/dist/test.js deleted file mode 100644 index 7e2eb90..0000000 --- a/dist/test.js +++ /dev/null @@ -1,47 +0,0 @@ -async function instantiate(module, imports = {}) { - const adaptedImports = { - env: Object.setPrototypeOf({ - abort(message, fileName, lineNumber, columnNumber) { - // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void - message = __liftString(message >>> 0); - fileName = __liftString(fileName >>> 0); - lineNumber = lineNumber >>> 0; - columnNumber = columnNumber >>> 0; - (() => { - // @external.js - throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); - })(); - }, - "console.log"(text) { - // ~lib/bindings/dom/console.log(~lib/string/String) => void - text = __liftString(text >>> 0); - console.log(text); - }, - }, Object.assign(Object.create(globalThis), imports.env || {})), - }; - const { exports } = await WebAssembly.instantiate(module, adaptedImports); - const memory = exports.memory || imports.env.memory; - function __liftString(pointer) { - if (!pointer) return null; - const - end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, - memoryU16 = new Uint16Array(memory.buffer); - let - start = pointer >>> 1, - string = ""; - while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); - return string + String.fromCharCode(...memoryU16.subarray(start, end)); - } - return exports; -} -export const { - memory, - runAllTests, -} = await (async url => instantiate( - await (async () => { - const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); - if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } - else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } - })(), { - } -))(new URL("test.wasm", import.meta.url)); diff --git a/dist/test.wasm b/dist/test.wasm deleted file mode 100644 index c893f4016987ad4e9d4a65e843c78c478f6a08af..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 189597 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 LesDH?H17WaNe@@g diff --git a/dist/test.wasm.map b/dist/test.wasm.map deleted file mode 100644 index af2d1b3..0000000 --- a/dist/test.wasm.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/bit.test.ts","~lib/util/hash.ts","~lib/map.ts","~lib/array.ts","assembly/test.ts","~lib/number.ts","~lib/string.ts","assembly/instructions/branch.ts","assembly/instructions/branch.test.ts","assembly/instructions/logic.ts","assembly/instructions/logic.test.ts","assembly/instructions/math.ts","assembly/instructions/math.test.ts","assembly/instructions/rot.ts","assembly/instructions/rot.test.ts","assembly/memory.test.ts","~lib/util/bytes.ts","~lib/console.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","assembly/instructions/mov.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions/misc.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/instructions.ts","assembly/program.ts","assembly/program.test.ts","assembly/spi.ts","assembly/spi.test.ts","assembly/test-run.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./test","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2dad002dad00?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16;\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = SEGMENT_SIZE;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport {\n count_set_bits_32,\n count_set_bits_64,\n leading_zero_bits_32,\n leading_zero_bits_64,\n reverse_bytes,\n sign_extend_8,\n sign_extend_16,\n trailing_zero_bits_32,\n trailing_zero_bits_64,\n zero_extend_16,\n} from \"./bit\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"count_set_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 2 * 8 + 4);\n return assert;\n }),\n test(\"count_set_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 4);\n return assert;\n }),\n test(\"leading_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 16);\n return assert;\n }),\n test(\"leading_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 19);\n return assert;\n }),\n test(\"trailing_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 36);\n return assert;\n }),\n test(\"trailing_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 32);\n return assert;\n }),\n test(\"sign_extend_8\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_8(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_ffef);\n return assert;\n }),\n test(\"sign_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_beef);\n return assert;\n }),\n test(\"zero_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = zero_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0x0000_beef);\n return assert;\n }),\n test(\"reverse_bytes\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_dead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = reverse_bytes(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xefbe_adde_f0ff_0000);\n return assert;\n }),\n];\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","export class Test {\n constructor(\n public name: string,\n public ptr: (assert: Assert) => Assert,\n ) {}\n}\n\nexport class Assert {\n public isOkay: boolean = true;\n public errors: string[] = [];\n\n static todo(): Assert {\n const r = new Assert();\n r.fail(\"Not implemented yet!\");\n return r;\n }\n\n fail(msg: string): void {\n this.isOkay = false;\n this.errors.push(msg);\n }\n\n isArrayEqual(actual: T[], expected: T[], msg: string = \"\"): void {\n this.isEqual(actual.length, expected.length, `length @ ${msg}`);\n this.isEqual(actual.join(\",\").toString(), expected.join(\",\").toString(), msg);\n }\n\n isEqual(actual: T, expected: T, msg: string = \"\"): void {\n if (actual !== expected) {\n this.isOkay = false;\n const actualDisplay = isInteger(actual) ? `${actual} (0x${actual.toString(16)})` : `${actual}`;\n const expectDisplay = isInteger(expected) ? `${expected} (0x${expected.toString(16)})` : `${expected}`;\n this.errors.push(`Got: '${actualDisplay}', expected: '${expectDisplay}' @ ${msg}`);\n }\n }\n}\n\nexport function test(name: string, ptr: (assert: Assert) => Assert): Test {\n return new Test(name, ptr);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { branch_eq_imm } from \"./branch\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"branch_eq_imm\", () => {\n // when\n const args = new Args();\n args.a = 0;\n args.b = 0xfe;\n args.c = 0xdeadbeef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfe;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = branch_eq_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.StaticJump, \"outcome\");\n assert.isEqual(ret.staticJump, 0xdeadbeef, \"staticJump\");\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { and_inv, or_inv, xnor } from \"./logic\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"and_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = and_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_f000_0000_0000);\n return assert;\n }),\n test(\"or_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = or_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fff1);\n return assert;\n }),\n test(\"xnor\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0000;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = xnor(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_0fff_ffff_fff0);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport * as math from \"./math\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"max\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"max_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"add_32\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = 2 ** 64 - 1;\n regs[reg(args.b)] = 2 ** 64 - 1;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.add_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fffe);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { Outcome } from \"./outcome\";\nimport { rot_l_32, rot_l_64, rot_r_64_imm, rot_r_64_imm_alt } from \"./rot\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"rot_r_64_imm\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xef00_0000_00de_adbe);\n return assert;\n }),\n test(\"rot_r_64_imm_alt\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0xdead_beef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm_alt(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xefff_ffff_ffde_adbe);\n return assert;\n }),\n test(\"rot_l_64\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_00de_adbe_ef00);\n return assert;\n }),\n test(\"rot_l_32\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_adbe_efde);\n return assert;\n }),\n];\n","import { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY, RESERVED_PAGES } from \"./memory-page\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"Show fail when accessing any of the initial 16 pages\", () => {\n const mem = new MemoryBuilder().build();\n\n const a = mem.getI8(0);\n const b = mem.getU64(RESERVED_MEMORY - 1);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, true, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.fault.fault, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 61440);\n return assert;\n }),\n test(\"Show fail on missing page or invalid access\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Read, RESERVED_MEMORY, new Uint8Array(10));\n const mem = builder.build();\n\n const a = mem.getU64(RESERVED_MEMORY);\n const b = mem.getU8((RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT);\n const c = mem.setU8(RESERVED_MEMORY, 12);\n const d = mem.getU8(RESERVED_MEMORY);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, false, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.ok, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 69632);\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, true, \"c.access\");\n assert.isEqual(c.fault, 65536);\n assert.isEqual(d.ok, 0);\n return assert;\n }),\n test(\"should read and write across pages\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Write, RESERVED_MEMORY, new Uint8Array(1));\n builder.setData(Access.Write, (RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT, new Uint8Array(1));\n const mem = builder.build();\n\n const out = new Uint8Array(16);\n const data = new Uint8Array(out.length);\n data.set([0xde, 0xad, 0xbe, 0xef], 0);\n\n const a = mem.bytesWrite(RESERVED_MEMORY + PAGE_SIZE - 10, data);\n const b = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE - 9, out);\n const c = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE * 2, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(a.isAccess, false, \"a.access\");\n assert.isEqual(a.fault, 0, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(b.isAccess, false, \"b.access\");\n assert.isEqual(b.fault, 0, \"b.fault\");\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, false, \"c.access\");\n assert.isEqual(out.toString(), \"173,190,239,0,0,0,0,0,0,0,0,0,0,0,0,0\");\n assert.isEqual(data.toString(), \"222,173,190,239,0,0,0,0,0,0,0,0,0,0,0,0\");\n return assert;\n }),\n test(\"should allow 0-bytes reads and writes everywhere\", () => {\n const mem = new MemoryBuilder().setData(Access.Read, RESERVED_MEMORY, new Uint8Array(0)).build();\n\n const out = new Uint8Array(0);\n\n // reserved pages\n const a = mem.bytesRead(0, out);\n const b = mem.bytesWrite(0, out);\n\n // not allocated\n const c = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n const d = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n\n // readable page\n const e = mem.bytesWrite(RESERVED_MEMORY, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(c.isFault, false, \"c.fault\");\n assert.isEqual(d.isFault, false, \"d.fault\");\n assert.isEqual(e.isFault, false, \"e.fault\");\n return assert;\n }),\n];\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { Arguments } from \"./arguments\";\nimport { RUN } from \"./instructions-exe\";\nimport { jump_ind } from \"./instructions/jump\";\nimport { trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport { BasicBlocks, JumpTable, Mask, deblob, decodeArguments } from \"./program\";\nimport { Assert, Test, test } from \"./test\";\n\nexport function u8arr(data: number[]): Uint8Array {\n const ret = new Uint8Array(data.length);\n ret.set(data, 0);\n return ret;\n}\n\nexport const TESTS: Test[] = [\n test(\"should parse packed mask correctly\", () => {\n const mask = new Mask(u8arr([0b0001_0000, 0b1000_0000, 0b1111_1000]), 21);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [4, 3, 2, 1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 3, 2, 1, 0, 0],\n );\n\n assert.isEqual(mask.isInstruction(0), false);\n assert.isEqual(mask.isInstruction(4), true);\n\n assert.isEqual(mask.skipBytesToNextInstruction(20), 0);\n assert.isEqual(mask.skipBytesToNextInstruction(22), 0);\n return assert;\n }),\n\n test(\"should not allow skipping more than 24 bytes\", () => {\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [\n 0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,\n 1, 0,\n ],\n );\n return assert;\n }),\n\n test(\"should decode arguments correctly\", () => {\n const data = u8arr([0xff, 0xff, 0xff, 0xff]);\n const args = decodeArguments(Arguments.OneImm, data, 4);\n\n const assert = new Assert();\n assert.isEqual(args.a, -1, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should decode positive bounded by skip\", () => {\n const data = u8arr([0x05, 0x05]);\n const args = decodeArguments(Arguments.OneImm, data, 1);\n\n const assert = new Assert();\n assert.isEqual(args.a, 5, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should deblob program\", () => {\n const raw = u8arr([\n 0, 0, 33, 51, 8, 1, 51, 9, 1, 40, 3, 0, 149, 119, 255, 81, 7, 12, 100, 138, 200, 152, 8, 100, 169, 40, 243, 100,\n 135, 51, 8, 51, 9, 1, 50, 0, 73, 147, 82, 213, 0,\n ]);\n const program = deblob(raw);\n const assert = new Assert();\n assert.isEqual(\n program.mask.toString(),\n \"Mask[0, 2, 1, 0, 2, 1, 0, 1, 0, 0, 2, 1, 0, 2, 1, 0, 1, 0, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, ]\",\n );\n assert.isEqual(program.jumpTable.toString(), \"JumpTable[]\");\n assert.isEqual(\n program.basicBlocks.toString(),\n \"BasicBlocks[0 -> start, 6 -> end, 8 -> startend, 9 -> start, 12 -> end, 15 -> start, 22 -> end, 24 -> start, 30 -> end, 31 -> startend, ]\",\n );\n return assert;\n }),\n\n test(\"should construct basic blocks correctly based on skip\", () => {\n const code = u8arr([\n opcode(trap),\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n opcode(jump_ind),\n ]);\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n const basicBlocks = new BasicBlocks(code, mask);\n const assert = new Assert();\n assert.isEqual(\n mask.toString(),\n \"Mask[0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, ]\",\n );\n assert.isEqual(basicBlocks.toString(), \"BasicBlocks[0 -> startend, 26 -> start, 31 -> end, ]\");\n return assert;\n }),\n test(\"should parse jump table with large numbers\", () => {\n const jumpTable = new JumpTable(\n 10,\n u8arr([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 2, 2, 2, 0]),\n );\n const assert = new Assert();\n assert.isEqual(\n jumpTable.toString(),\n \"JumpTable[0 -> 18446744073709551615, 1 -> 18446744073709551615, 2 -> 18446744073709551615, ]\",\n );\n return assert;\n }),\n];\n\nfunction opcode(search: InstructionRun): number {\n const idx = RUN.indexOf(search);\n if (idx < 0) {\n throw new Error(\"Opcode not found in RUN table for instruction\");\n }\n return idx;\n}\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { Program, deblob } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const DATA_LENGTH: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - DATA_LENGTH;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = 2 ** 32 - 2 * SEGMENT_SIZE - DATA_LENGTH;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > DATA_LENGTH) {\n throw new Error(\"Arguments length too big\");\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { liftBytes } from \"./program\";\nimport { decodeSpi } from \"./spi\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"should decode standard program\", () => {\n const PROGRAM = liftBytes([\n 0x04, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0xab, 0xcd, 0xef, 0x01, 0x12, 0x34, 0x07, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x03, 0xc8, 0x87, 0x09, 0x01,\n ]);\n const ARGS = liftBytes([0x12, 0x34, 0x56]);\n\n const spi = decodeSpi(PROGRAM, ARGS);\n\n const assert = new Assert();\n assert.isEqual(\n spi.toString(),\n \"StandardProgram { program: Program { code: 200,135,9, mask: Mask[0, 2, 1, ], jumpTable: JumpTable[], basicBlocks: BasicBlocks[0 -> start, ] }, memory_pages: 7, registers: 4294901760,4278059008,0,0,0,0,0,4278124544,3,0,0,0,0 }\",\n );\n return assert;\n }),\n];\n","import * as bit from \"./instructions/bit.test\";\nimport * as branch from \"./instructions/branch.test\";\nimport * as logic from \"./instructions/logic.test\";\nimport * as math from \"./instructions/math.test\";\nimport * as rot from \"./instructions/rot.test\";\nimport * as memory from \"./memory.test\";\nimport * as program from \"./program.test\";\nimport * as spi from \"./spi.test\";\nimport { Assert, Test } from \"./test\";\n\nexport function runAllTests(): void {\n let a: u64 = 0;\n\n a += run(bit.TESTS, \"bit.ts\");\n a += run(branch.TESTS, \"branch.ts\");\n a += run(logic.TESTS, \"logic.ts\");\n a += run(math.TESTS, \"math.ts\");\n a += run(memory.TESTS, \"memory.ts\");\n a += run(program.TESTS, \"program.ts\");\n a += run(rot.TESTS, \"rot.ts\");\n a += run(spi.TESTS, \"spi.ts\");\n\n const okay = u32(a >> 32);\n const total = u32(a);\n\n printSummary(\"\\n\\nTotal\", okay, total);\n if (okay !== total) {\n throw new Error(\"Some tests failed.\");\n }\n}\n\nfunction run(tests: Test[], file: string): u64 {\n let ok = 0;\n console.log(`> ${file}`);\n for (let i = 0; i < tests.length; i++) {\n console.log(` >>> ${tests[i].name}`);\n const res = tests[i].ptr(new Assert());\n if (res.isOkay) {\n console.log(` <<< ${tests[i].name} ✅`);\n ok += 1;\n } else {\n for (let j = 0; j < res.errors.length; j++) {\n console.log(` ${res.errors[j]}`);\n }\n console.log(` <<< ${tests[i].name} 🔴`);\n }\n }\n\n printSummary(`< ${file}`, ok, tests.length);\n\n return (u64(ok) << 32) + tests.length;\n}\n\nfunction printSummary(msg: string, okay: u32, total: u32): void {\n const ico = okay === total ? \"✅\" : \"🔴\";\n console.log(`${msg} ${okay} / ${total} ${ico}`);\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/dist/test.wat b/dist/test.wat deleted file mode 100644 index c8dd9d6..0000000 --- a/dist/test.wat +++ /dev/null @@ -1,45369 +0,0 @@ -(module - (type $0 (func (param i32) (result i32))) - (type $1 (func (param i32 i32 i32) (result i32))) - (type $2 (func (param i32 i32))) - (type $3 (func (param i32 i32) (result i32))) - (type $4 (func)) - (type $5 (func (param i32 i32 i32))) - (type $6 (func (param i32 i32 i32 i32) (result i32))) - (type $7 (func (param i32))) - (type $8 (func (param i32 i32 i32 i32))) - (type $9 (func (param i64 i64) (result i64))) - (type $10 (func (param i64 i32) (result i32))) - (type $11 (func (result i32))) - (type $12 (func (param i32) (result i64))) - (type $13 (func (param i32 i64))) - (type $14 (func (param i32 i32 i64) (result i32))) - (type $15 (func (param i64) (result i32))) - (type $16 (func (param i32 i32 i64))) - (type $17 (func (param i32 i64 i32))) - (type $18 (func (param i32 i32 i32 i32 i32) (result i32))) - (type $19 (func (param i32 i32) (result i64))) - (type $20 (func (param i32 i64 i64 i32))) - (type $21 (func (param i64) (result i64))) - (type $22 (func (param i32 i64 i32 i32))) - (type $23 (func (param i32 i32 i32 i32 i32))) - (type $24 (func (param i32 i32 i64 i32) (result i32))) - (type $25 (func (param i32 i64) (result i32))) - (type $26 (func (param i32) (result f64))) - (type $27 (func (param i32 i32 f64))) - (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) - (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) - (global $assembly/arguments/Arguments.Zero i32 (i32.const 0)) - (global $assembly/arguments/Arguments.OneImm i32 (i32.const 1)) - (global $assembly/arguments/Arguments.TwoImm i32 (i32.const 2)) - (global $assembly/arguments/Arguments.OneOff i32 (i32.const 3)) - (global $assembly/arguments/Arguments.OneRegOneImm i32 (i32.const 4)) - (global $assembly/arguments/Arguments.OneRegOneExtImm i32 (i32.const 5)) - (global $assembly/arguments/Arguments.OneRegTwoImm i32 (i32.const 6)) - (global $assembly/arguments/Arguments.OneRegOneImmOneOff i32 (i32.const 7)) - (global $assembly/arguments/Arguments.TwoReg i32 (i32.const 8)) - (global $assembly/arguments/Arguments.TwoRegOneImm i32 (i32.const 9)) - (global $assembly/arguments/Arguments.TwoRegOneOff i32 (i32.const 10)) - (global $assembly/arguments/Arguments.TwoRegTwoImm i32 (i32.const 11)) - (global $assembly/arguments/Arguments.ThreeReg i32 (i32.const 12)) - (global $assembly/arguments/RELEVANT_ARGS i32 (i32.const 112)) - (global $assembly/arguments/REQUIRED_BYTES i32 (i32.const 240)) - (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) - (global $~lib/shared/runtime/Runtime.Stub i32 (i32.const 0)) - (global $~lib/shared/runtime/Runtime.Minimal i32 (i32.const 1)) - (global $~lib/shared/runtime/Runtime.Incremental i32 (i32.const 2)) - (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) - (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) - (global $~lib/native/ASC_LOW_MEMORY_LIMIT i32 (i32.const 0)) - (global $~lib/builtins/i32.MAX_VALUE i32 (i32.const 2147483647)) - (global $~argumentsLength (mut i32) (i32.const 0)) - (global $assembly/arguments/DECODERS i32 (i32.const 1248)) - (global $assembly/registers/NO_OF_REGISTERS i32 (i32.const 13)) - (global $assembly/registers/REG_SIZE_BYTES i32 (i32.const 8)) - (global $assembly/memory-page/PAGE_SIZE i32 (i32.const 4096)) - (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) - (global $~lib/native/ASC_SHRINK_LEVEL i32 (i32.const 0)) - (global $assembly/memory-page/SEGMENT_SIZE (mut i32) (i32.const 0)) - (global $assembly/memory-page/SEGMENT_SIZE_SHIFT i32 (i32.const 16)) - (global $assembly/memory-page/RESERVED_MEMORY (mut i32) (i32.const 0)) - (global $assembly/memory-page/RESERVED_PAGES (mut i32) (i32.const 0)) - (global $assembly/memory-page/ALLOCATE_EAGERLY (mut i32) (i32.const 0)) - (global $assembly/memory-page/Access.None i32 (i32.const 0)) - (global $assembly/memory-page/Access.Read i32 (i32.const 1)) - (global $assembly/memory-page/Access.Write i32 (i32.const 2)) - (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) - (global $assembly/memory/MEMORY_SIZE i64 (i64.const 4294967296)) - (global $~lib/native/ASC_RUNTIME i32 (i32.const 2)) - (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) - (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) - (global $assembly/instructions/outcome/Result.PANIC i32 (i32.const 0)) - (global $assembly/instructions/outcome/Result.FAULT i32 (i32.const 1)) - (global $assembly/instructions/outcome/Result.FAULT_ACCESS i32 (i32.const 2)) - (global $assembly/instructions/outcome/Result.HOST i32 (i32.const 3)) - (global $assembly/instructions/outcome/Outcome.Ok i32 (i32.const 0)) - (global $assembly/instructions/outcome/Outcome.StaticJump i32 (i32.const 1)) - (global $assembly/instructions/outcome/Outcome.DynamicJump i32 (i32.const 2)) - (global $assembly/instructions/outcome/Outcome.Result i32 (i32.const 3)) - (global $assembly/instructions/bit/count_set_bits_64 i32 (i32.const 1472)) - (global $assembly/instructions/bit/count_set_bits_32 i32 (i32.const 1504)) - (global $assembly/instructions/bit/leading_zero_bits_64 i32 (i32.const 1536)) - (global $assembly/instructions/bit/leading_zero_bits_32 i32 (i32.const 1568)) - (global $assembly/instructions/bit/trailing_zero_bits_64 i32 (i32.const 1600)) - (global $assembly/instructions/bit/trailing_zero_bits_32 i32 (i32.const 1632)) - (global $assembly/instructions/bit/sign_extend_8 i32 (i32.const 1664)) - (global $assembly/instructions/bit/sign_extend_16 i32 (i32.const 1696)) - (global $assembly/instructions/bit/zero_extend_16 i32 (i32.const 1728)) - (global $assembly/instructions/bit/reverse_bytes i32 (i32.const 1760)) - (global $~lib/builtins/u32.MAX_VALUE i32 (i32.const -1)) - (global $assembly/instructions/bit.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/instructions/branch/branch_eq_imm i32 (i32.const 5440)) - (global $assembly/instructions/branch/branch_ne_imm i32 (i32.const 5472)) - (global $assembly/instructions/branch/branch_lt_u_imm i32 (i32.const 5504)) - (global $assembly/instructions/branch/branch_le_u_imm i32 (i32.const 5536)) - (global $assembly/instructions/branch/branch_ge_u_imm i32 (i32.const 5568)) - (global $assembly/instructions/branch/branch_gt_u_imm i32 (i32.const 5600)) - (global $assembly/instructions/branch/branch_lt_s_imm i32 (i32.const 5632)) - (global $assembly/instructions/branch/branch_le_s_imm i32 (i32.const 5664)) - (global $assembly/instructions/branch/branch_ge_s_imm i32 (i32.const 5696)) - (global $assembly/instructions/branch/branch_gt_s_imm i32 (i32.const 5728)) - (global $assembly/instructions/branch/branch_eq i32 (i32.const 5760)) - (global $assembly/instructions/branch/branch_ne i32 (i32.const 5792)) - (global $assembly/instructions/branch/branch_lt_u i32 (i32.const 5824)) - (global $assembly/instructions/branch/branch_lt_s i32 (i32.const 5856)) - (global $assembly/instructions/branch/branch_ge_u i32 (i32.const 5888)) - (global $assembly/instructions/branch/branch_ge_s i32 (i32.const 5920)) - (global $assembly/instructions/branch.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/instructions/logic/and_imm i32 (i32.const 6224)) - (global $assembly/instructions/logic/xor_imm i32 (i32.const 6256)) - (global $assembly/instructions/logic/or_imm i32 (i32.const 6288)) - (global $assembly/instructions/logic/and i32 (i32.const 6320)) - (global $assembly/instructions/logic/xor i32 (i32.const 6352)) - (global $assembly/instructions/logic/or i32 (i32.const 6384)) - (global $assembly/instructions/logic/and_inv i32 (i32.const 6416)) - (global $assembly/instructions/logic/or_inv i32 (i32.const 6448)) - (global $assembly/instructions/logic/xnor i32 (i32.const 6480)) - (global $assembly/instructions/logic.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/instructions/math/add_imm_32 i32 (i32.const 6720)) - (global $assembly/instructions/math/mul_imm_32 i32 (i32.const 6752)) - (global $assembly/instructions/math/neg_add_imm_32 i32 (i32.const 6784)) - (global $assembly/instructions/math/add_imm i32 (i32.const 6816)) - (global $assembly/instructions/math/mul_imm i32 (i32.const 6848)) - (global $assembly/instructions/math/neg_add_imm i32 (i32.const 6880)) - (global $assembly/instructions/math/add_32 i32 (i32.const 6912)) - (global $assembly/instructions/math/sub_32 i32 (i32.const 6944)) - (global $assembly/instructions/math/mul_32 i32 (i32.const 6976)) - (global $~lib/builtins/u64.MAX_VALUE i64 (i64.const -1)) - (global $assembly/instructions/math/div_u_32 i32 (i32.const 7008)) - (global $~lib/builtins/i32.MIN_VALUE i32 (i32.const -2147483648)) - (global $assembly/instructions/math/div_s_32 i32 (i32.const 7040)) - (global $assembly/instructions/math/rem_u_32 i32 (i32.const 7072)) - (global $assembly/instructions/math/rem_s_32 i32 (i32.const 7104)) - (global $assembly/instructions/math/add_64 i32 (i32.const 7136)) - (global $assembly/instructions/math/sub i32 (i32.const 7168)) - (global $assembly/instructions/math/mul i32 (i32.const 7200)) - (global $assembly/instructions/math/div_u i32 (i32.const 7232)) - (global $~lib/builtins/i64.MIN_VALUE i64 (i64.const -9223372036854775808)) - (global $assembly/instructions/math/div_s i32 (i32.const 7264)) - (global $assembly/instructions/math/rem_u i32 (i32.const 7296)) - (global $assembly/instructions/math/rem_s i32 (i32.const 7328)) - (global $assembly/instructions/math/mul_upper_s_s i32 (i32.const 7360)) - (global $assembly/instructions/math/mul_upper_u_u i32 (i32.const 7392)) - (global $assembly/instructions/math/mul_upper_s_u i32 (i32.const 7424)) - (global $assembly/instructions/math/max i32 (i32.const 7456)) - (global $assembly/instructions/math/max_u i32 (i32.const 7488)) - (global $assembly/instructions/math/min i32 (i32.const 7520)) - (global $assembly/instructions/math/min_u i32 (i32.const 7552)) - (global $assembly/instructions/math.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/instructions/rot/rot_r_64_imm i32 (i32.const 7904)) - (global $assembly/instructions/rot/rot_r_64_imm_alt i32 (i32.const 7936)) - (global $assembly/instructions/rot/rot_r_32_imm i32 (i32.const 7968)) - (global $assembly/instructions/rot/rot_r_32_imm_alt i32 (i32.const 8000)) - (global $assembly/instructions/rot/rot_l_64 i32 (i32.const 8032)) - (global $assembly/instructions/rot/rot_l_32 i32 (i32.const 8064)) - (global $assembly/instructions/rot/rot_r_64 i32 (i32.const 8096)) - (global $assembly/instructions/rot/rot_r_32 i32 (i32.const 8128)) - (global $assembly/instructions/rot.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/memory.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/instructions/jump/jump i32 (i32.const 10576)) - (global $assembly/instructions/jump/jump_ind i32 (i32.const 10608)) - (global $assembly/instructions/jump/load_imm_jump i32 (i32.const 10640)) - (global $assembly/instructions/jump/load_imm_jump_ind i32 (i32.const 10672)) - (global $assembly/instructions/load/load_imm_64 i32 (i32.const 10704)) - (global $assembly/instructions/load/load_imm i32 (i32.const 10736)) - (global $assembly/instructions/load/load_u8 i32 (i32.const 10768)) - (global $assembly/instructions/load/load_i8 i32 (i32.const 10800)) - (global $assembly/instructions/load/load_u16 i32 (i32.const 10832)) - (global $assembly/instructions/load/load_i16 i32 (i32.const 10864)) - (global $assembly/instructions/load/load_u32 i32 (i32.const 10896)) - (global $assembly/instructions/load/load_i32 i32 (i32.const 10928)) - (global $assembly/instructions/load/load_u64 i32 (i32.const 10960)) - (global $assembly/instructions/load/load_ind_u8 i32 (i32.const 10992)) - (global $assembly/instructions/load/load_ind_i8 i32 (i32.const 11024)) - (global $assembly/instructions/load/load_ind_u16 i32 (i32.const 11056)) - (global $assembly/instructions/load/load_ind_i16 i32 (i32.const 11088)) - (global $assembly/instructions/load/load_ind_u32 i32 (i32.const 11120)) - (global $assembly/instructions/load/load_ind_i32 i32 (i32.const 11152)) - (global $assembly/instructions/load/load_ind_u64 i32 (i32.const 11184)) - (global $assembly/instructions/mov/move_reg i32 (i32.const 11216)) - (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11248)) - (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11280)) - (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11312)) - (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11344)) - (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 11376)) - (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 11408)) - (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 11440)) - (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 11472)) - (global $assembly/instructions/set/set_lt_u i32 (i32.const 11504)) - (global $assembly/instructions/set/set_lt_s i32 (i32.const 11536)) - (global $assembly/instructions/shift/MAX_SHIFT_64 i32 (i32.const 64)) - (global $assembly/instructions/shift/MAX_SHIFT_32 i32 (i32.const 32)) - (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 11568)) - (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 11600)) - (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 11632)) - (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 11664)) - (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 11696)) - (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 11728)) - (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 11760)) - (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 11792)) - (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 11824)) - (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 11856)) - (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 11888)) - (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 11920)) - (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 11952)) - (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 11984)) - (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12016)) - (global $assembly/instructions/shift/shlo_l i32 (i32.const 12048)) - (global $assembly/instructions/shift/shlo_r i32 (i32.const 12080)) - (global $assembly/instructions/shift/shar_r i32 (i32.const 12112)) - (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12144)) - (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12176)) - (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12208)) - (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12240)) - (global $assembly/instructions/store/store_u8 i32 (i32.const 12272)) - (global $assembly/instructions/store/store_u16 i32 (i32.const 12304)) - (global $assembly/instructions/store/store_u32 i32 (i32.const 12336)) - (global $assembly/instructions/store/store_u64 i32 (i32.const 12368)) - (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 12400)) - (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 12432)) - (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 12464)) - (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 12496)) - (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 12528)) - (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 12560)) - (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 12592)) - (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 12624)) - (global $assembly/instructions/misc/INVALID i32 (i32.const 12656)) - (global $assembly/instructions/misc/trap i32 (i32.const 12688)) - (global $assembly/instructions/misc/fallthrough i32 (i32.const 12720)) - (global $assembly/instructions/misc/ecalli i32 (i32.const 12752)) - (global $assembly/instructions/misc/sbrk i32 (i32.const 12784)) - (global $assembly/instructions-exe/RUN i32 (i32.const 13760)) - (global $assembly/codec/MASKS i32 (i32.const 13840)) - (global $assembly/codec/variableLength i32 (i32.const 13888)) - (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) - (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) - (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) - (global $assembly/program/MAX_SKIP i32 (i32.const 24)) - (global $assembly/program/BasicBlock.NONE i32 (i32.const 0)) - (global $assembly/program/BasicBlock.START i32 (i32.const 2)) - (global $assembly/program/BasicBlock.END i32 (i32.const 4)) - (global $assembly/program.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/spi/DATA_LENGTH (mut i32) (i32.const 0)) - (global $assembly/spi/ARGS_SEGMENT_START (mut i32) (i32.const 0)) - (global $assembly/spi/STACK_SEGMENT_END (mut i32) (i32.const 0)) - (global $assembly/spi.test/TESTS (mut i32) (i32.const 0)) - (global $~lib/rt/__rtti_base i32 (i32.const 27856)) - (global $~lib/memory/__data_end i32 (i32.const 28052)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 60820)) - (global $~lib/memory/__heap_base i32 (i32.const 60820)) - (memory $0 1) - (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") - (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $2 (i32.const 140) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") - (data $3 (i32.const 220) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00\a0\00\00\00\a0\00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $4 (i32.const 268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e\00\00\00\00\00") - (data $5 (i32.const 332) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $6 (i32.const 400) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $7 (i32.const 432) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $8 (i32.const 460) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e\00\00\00\00\00\00\00\00\00") - (data $9 (i32.const 524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $10 (i32.const 576) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $11 (i32.const 604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $12 (i32.const 668) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00") - (data $13 (i32.const 700) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $14 (i32.const 764) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") - (data $15 (i32.const 796) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") - (data $16 (i32.const 828) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\04\00\00\00\00\00\00\00\00\00\00\00") - (data $17 (i32.const 860) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\05\00\00\00\00\00\00\00\00\00\00\00") - (data $18 (i32.const 892) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\06\00\00\00\00\00\00\00\00\00\00\00") - (data $19 (i32.const 924) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\07\00\00\00\00\00\00\00\00\00\00\00") - (data $20 (i32.const 956) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00") - (data $21 (i32.const 988) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\t\00\00\00\00\00\00\00\00\00\00\00") - (data $22 (i32.const 1020) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") - (data $23 (i32.const 1052) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0b\00\00\00\00\00\00\00\00\00\00\00") - (data $24 (i32.const 1084) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0c\00\00\00\00\00\00\00\00\00\00\00") - (data $25 (i32.const 1116) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00") - (data $26 (i32.const 1148) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\b0\02\00\00\10\03\00\000\03\00\00P\03\00\00p\03\00\00\90\03\00\00\b0\03\00\00\d0\03\00\00\f0\03\00\00\10\04\00\000\04\00\00P\04\00\00p\04\00\00\00\00\00\00\00\00\00\00") - (data $27 (i32.const 1228) ",\00\00\00\00\00\00\00\00\00\00\00\07\00\00\00\10\00\00\00\90\04\00\00\90\04\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $28 (i32.const 1276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h\00") - (data $29 (i32.const 1324) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") - (data $30 (i32.const 1388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00") - (data $31 (i32.const 1452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\0e\00\00\00\00\00\00\00\00\00\00\00") - (data $32 (i32.const 1484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\0f\00\00\00\00\00\00\00\00\00\00\00") - (data $33 (i32.const 1516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\10\00\00\00\00\00\00\00\00\00\00\00") - (data $34 (i32.const 1548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\11\00\00\00\00\00\00\00\00\00\00\00") - (data $35 (i32.const 1580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\12\00\00\00\00\00\00\00\00\00\00\00") - (data $36 (i32.const 1612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\13\00\00\00\00\00\00\00\00\00\00\00") - (data $37 (i32.const 1644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\14\00\00\00\00\00\00\00\00\00\00\00") - (data $38 (i32.const 1676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\15\00\00\00\00\00\00\00\00\00\00\00") - (data $39 (i32.const 1708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\16\00\00\00\00\00\00\00\00\00\00\00") - (data $40 (i32.const 1740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\17\00\00\00\00\00\00\00\00\00\00\00") - (data $41 (i32.const 1772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00c\00o\00u\00n\00t\00_\00s\00e\00t\00_\00b\00i\00t\00s\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $42 (i32.const 1836) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $43 (i32.const 1868) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00") - (data $44 (i32.const 1916) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!\00\00\00\00\00\00\00") - (data $45 (i32.const 2028) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $46 (i32.const 2092) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $47 (i32.const 2124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00o\00u\00t\00c\00o\00m\00e\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $48 (i32.const 2172) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00(\000\00x\00\00\00\00\00") - (data $49 (i32.const 2204) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") - (data $50 (i32.const 2236) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $51 (i32.const 2284) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006\00\00\00\00\00\00\00\00\00") - (data $52 (i32.const 2412) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") - (data $53 (i32.const 2476) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\000\00\00\00\00\00\00\00\00\00\00\00") - (data $54 (i32.const 2508) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\00") - (data $55 (i32.const 2908) "\1c\04\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $56 (i32.const 3964) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z\00\00\00\00\00") - (data $57 (i32.const 4060) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $58 (i32.const 4092) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $59 (i32.const 4140) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00G\00o\00t\00:\00 \00\'\00") - (data $60 (i32.const 4172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00\'\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 \00\'\00") - (data $61 (i32.const 4220) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00\'\00 \00@\00 \00\00\00\00\00") - (data $62 (i32.const 4252) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $63 (i32.const 4300) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $64 (i32.const 4348) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $65 (i32.const 4396) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $66 (i32.const 4444) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\18\00\00\00\00\00\00\00\00\00\00\00") - (data $67 (i32.const 4476) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00c\00o\00u\00n\00t\00_\00s\00e\00t\00_\00b\00i\00t\00s\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $68 (i32.const 4540) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\19\00\00\00\00\00\00\00\00\00\00\00") - (data $69 (i32.const 4572) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00l\00e\00a\00d\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\006\004\00\00\00\00\00") - (data $70 (i32.const 4636) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1a\00\00\00\00\00\00\00\00\00\00\00") - (data $71 (i32.const 4668) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00l\00e\00a\00d\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\003\002\00\00\00\00\00") - (data $72 (i32.const 4732) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1b\00\00\00\00\00\00\00\00\00\00\00") - (data $73 (i32.const 4764) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00t\00r\00a\00i\00l\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\006\004\00\00\00") - (data $74 (i32.const 4828) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1c\00\00\00\00\00\00\00\00\00\00\00") - (data $75 (i32.const 4860) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00t\00r\00a\00i\00l\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\003\002\00\00\00") - (data $76 (i32.const 4924) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1d\00\00\00\00\00\00\00\00\00\00\00") - (data $77 (i32.const 4956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00s\00i\00g\00n\00_\00e\00x\00t\00e\00n\00d\00_\008\00\00\00") - (data $78 (i32.const 5004) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1e\00\00\00\00\00\00\00\00\00\00\00") - (data $79 (i32.const 5036) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00s\00i\00g\00n\00_\00e\00x\00t\00e\00n\00d\00_\001\006\00") - (data $80 (i32.const 5084) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1f\00\00\00\00\00\00\00\00\00\00\00") - (data $81 (i32.const 5116) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00z\00e\00r\00o\00_\00e\00x\00t\00e\00n\00d\00_\001\006\00") - (data $82 (i32.const 5164) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $83 (i32.const 5196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00r\00e\00v\00e\00r\00s\00e\00_\00b\00y\00t\00e\00s\00\00\00") - (data $84 (i32.const 5244) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $85 (i32.const 5292) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $86 (i32.const 5340) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $87 (i32.const 5388) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00!\00\00\00\00\00\00\00\00\00\00\00") - (data $88 (i32.const 5420) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\"\00\00\00\00\00\00\00\00\00\00\00") - (data $89 (i32.const 5452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00#\00\00\00\00\00\00\00\00\00\00\00") - (data $90 (i32.const 5484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00$\00\00\00\00\00\00\00\00\00\00\00") - (data $91 (i32.const 5516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00%\00\00\00\00\00\00\00\00\00\00\00") - (data $92 (i32.const 5548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00&\00\00\00\00\00\00\00\00\00\00\00") - (data $93 (i32.const 5580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\'\00\00\00\00\00\00\00\00\00\00\00") - (data $94 (i32.const 5612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") - (data $95 (i32.const 5644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") - (data $96 (i32.const 5676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00*\00\00\00\00\00\00\00\00\00\00\00") - (data $97 (i32.const 5708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00+\00\00\00\00\00\00\00\00\00\00\00") - (data $98 (i32.const 5740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") - (data $99 (i32.const 5772) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00-\00\00\00\00\00\00\00\00\00\00\00") - (data $100 (i32.const 5804) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00.\00\00\00\00\00\00\00\00\00\00\00") - (data $101 (i32.const 5836) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00/\00\00\00\00\00\00\00\00\00\00\00") - (data $102 (i32.const 5868) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\000\00\00\00\00\00\00\00\00\00\00\00") - (data $103 (i32.const 5900) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\001\00\00\00\00\00\00\00\00\00\00\00") - (data $104 (i32.const 5932) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00b\00r\00a\00n\00c\00h\00_\00e\00q\00_\00i\00m\00m\00\00\00") - (data $105 (i32.const 5980) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00s\00t\00a\00t\00i\00c\00J\00u\00m\00p\00\00\00\00\00\00\00\00\00") - (data $106 (i32.const 6028) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $107 (i32.const 6076) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $108 (i32.const 6124) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $109 (i32.const 6172) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\002\00\00\00\00\00\00\00\00\00\00\00") - (data $110 (i32.const 6204) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\003\00\00\00\00\00\00\00\00\00\00\00") - (data $111 (i32.const 6236) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\004\00\00\00\00\00\00\00\00\00\00\00") - (data $112 (i32.const 6268) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\005\00\00\00\00\00\00\00\00\00\00\00") - (data $113 (i32.const 6300) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\006\00\00\00\00\00\00\00\00\00\00\00") - (data $114 (i32.const 6332) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\007\00\00\00\00\00\00\00\00\00\00\00") - (data $115 (i32.const 6364) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\008\00\00\00\00\00\00\00\00\00\00\00") - (data $116 (i32.const 6396) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\009\00\00\00\00\00\00\00\00\00\00\00") - (data $117 (i32.const 6428) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00:\00\00\00\00\00\00\00\00\00\00\00") - (data $118 (i32.const 6460) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00;\00\00\00\00\00\00\00\00\00\00\00") - (data $119 (i32.const 6492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00a\00n\00d\00_\00i\00n\00v\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $120 (i32.const 6540) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00<\00\00\00\00\00\00\00\00\00\00\00") - (data $121 (i32.const 6572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00o\00r\00_\00i\00n\00v\00") - (data $122 (i32.const 6604) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00=\00\00\00\00\00\00\00\00\00\00\00") - (data $123 (i32.const 6636) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00x\00n\00o\00r\00\00\00\00\00") - (data $124 (i32.const 6668) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00>\00\00\00\00\00\00\00\00\00\00\00") - (data $125 (i32.const 6700) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00?\00\00\00\00\00\00\00\00\00\00\00") - (data $126 (i32.const 6732) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00@\00\00\00\00\00\00\00\00\00\00\00") - (data $127 (i32.const 6764) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00A\00\00\00\00\00\00\00\00\00\00\00") - (data $128 (i32.const 6796) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00B\00\00\00\00\00\00\00\00\00\00\00") - (data $129 (i32.const 6828) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00C\00\00\00\00\00\00\00\00\00\00\00") - (data $130 (i32.const 6860) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00D\00\00\00\00\00\00\00\00\00\00\00") - (data $131 (i32.const 6892) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00E\00\00\00\00\00\00\00\00\00\00\00") - (data $132 (i32.const 6924) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00F\00\00\00\00\00\00\00\00\00\00\00") - (data $133 (i32.const 6956) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00G\00\00\00\00\00\00\00\00\00\00\00") - (data $134 (i32.const 6988) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00H\00\00\00\00\00\00\00\00\00\00\00") - (data $135 (i32.const 7020) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00I\00\00\00\00\00\00\00\00\00\00\00") - (data $136 (i32.const 7052) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00J\00\00\00\00\00\00\00\00\00\00\00") - (data $137 (i32.const 7084) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00K\00\00\00\00\00\00\00\00\00\00\00") - (data $138 (i32.const 7116) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00L\00\00\00\00\00\00\00\00\00\00\00") - (data $139 (i32.const 7148) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00M\00\00\00\00\00\00\00\00\00\00\00") - (data $140 (i32.const 7180) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00N\00\00\00\00\00\00\00\00\00\00\00") - (data $141 (i32.const 7212) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00O\00\00\00\00\00\00\00\00\00\00\00") - (data $142 (i32.const 7244) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00P\00\00\00\00\00\00\00\00\00\00\00") - (data $143 (i32.const 7276) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00Q\00\00\00\00\00\00\00\00\00\00\00") - (data $144 (i32.const 7308) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00R\00\00\00\00\00\00\00\00\00\00\00") - (data $145 (i32.const 7340) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00S\00\00\00\00\00\00\00\00\00\00\00") - (data $146 (i32.const 7372) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00T\00\00\00\00\00\00\00\00\00\00\00") - (data $147 (i32.const 7404) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00U\00\00\00\00\00\00\00\00\00\00\00") - (data $148 (i32.const 7436) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00V\00\00\00\00\00\00\00\00\00\00\00") - (data $149 (i32.const 7468) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00W\00\00\00\00\00\00\00\00\00\00\00") - (data $150 (i32.const 7500) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00X\00\00\00\00\00\00\00\00\00\00\00") - (data $151 (i32.const 7532) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00Y\00\00\00\00\00\00\00\00\00\00\00") - (data $152 (i32.const 7564) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00m\00a\00x\00\00\00\00\00\00\00") - (data $153 (i32.const 7596) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00Z\00\00\00\00\00\00\00\00\00\00\00") - (data $154 (i32.const 7628) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00m\00a\00x\00_\00u\00\00\00") - (data $155 (i32.const 7660) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00[\00\00\00\00\00\00\00\00\00\00\00") - (data $156 (i32.const 7692) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00m\00i\00n\00\00\00\00\00\00\00") - (data $157 (i32.const 7724) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\\\00\00\00\00\00\00\00\00\00\00\00") - (data $158 (i32.const 7756) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00m\00i\00n\00_\00u\00\00\00") - (data $159 (i32.const 7788) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") - (data $160 (i32.const 7820) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00a\00d\00d\00_\003\002\00") - (data $161 (i32.const 7852) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00^\00\00\00\00\00\00\00\00\00\00\00") - (data $162 (i32.const 7884) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00_\00\00\00\00\00\00\00\00\00\00\00") - (data $163 (i32.const 7916) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00`\00\00\00\00\00\00\00\00\00\00\00") - (data $164 (i32.const 7948) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") - (data $165 (i32.const 7980) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") - (data $166 (i32.const 8012) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") - (data $167 (i32.const 8044) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") - (data $168 (i32.const 8076) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00e\00\00\00\00\00\00\00\00\00\00\00") - (data $169 (i32.const 8108) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00f\00\00\00\00\00\00\00\00\00\00\00") - (data $170 (i32.const 8140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00r\00o\00t\00_\00r\00_\006\004\00_\00i\00m\00m\00\00\00\00\00") - (data $171 (i32.const 8188) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00g\00\00\00\00\00\00\00\00\00\00\00") - (data $172 (i32.const 8220) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00r\00o\00t\00_\00r\00_\006\004\00_\00i\00m\00m\00_\00a\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $173 (i32.const 8284) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00h\00\00\00\00\00\00\00\00\00\00\00") - (data $174 (i32.const 8316) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00r\00o\00t\00_\00l\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $175 (i32.const 8364) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00i\00\00\00\00\00\00\00\00\00\00\00") - (data $176 (i32.const 8396) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00r\00o\00t\00_\00l\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $177 (i32.const 8444) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00j\00\00\00\00\00\00\00\00\00\00\00") - (data $178 (i32.const 8476) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00h\00\00\00S\00h\00o\00w\00 \00f\00a\00i\00l\00 \00w\00h\00e\00n\00 \00a\00c\00c\00e\00s\00s\00i\00n\00g\00 \00a\00n\00y\00 \00o\00f\00 \00t\00h\00e\00 \00i\00n\00i\00t\00i\00a\00l\00 \001\006\00 \00p\00a\00g\00e\00s\00\00\00\00\00") - (data $179 (i32.const 8604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t\00\00\00\00\00\00\00\00\00") - (data $180 (i32.const 8668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s\00\00\00\00\00\00\00") - (data $181 (i32.const 8716) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $182 (i32.const 8844) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $183 (i32.const 8924) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00a\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $184 (i32.const 8972) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $185 (i32.const 9020) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00t\00r\00u\00e\00\00\00\00\00") - (data $186 (i32.const 9052) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00f\00a\00l\00s\00e\00\00\00") - (data $187 (i32.const 9084) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $188 (i32.const 9132) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $189 (i32.const 9180) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00a\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $190 (i32.const 9228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00b\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $191 (i32.const 9276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00b\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $192 (i32.const 9324) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00k\00\00\00\00\00\00\00\00\00\00\00") - (data $193 (i32.const 9356) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00S\00h\00o\00w\00 \00f\00a\00i\00l\00 \00o\00n\00 \00m\00i\00s\00s\00i\00n\00g\00 \00p\00a\00g\00e\00 \00o\00r\00 \00i\00n\00v\00a\00l\00i\00d\00 \00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00") - (data $194 (i32.const 9468) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 \00") - (data $195 (i32.const 9564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y\00") - (data $196 (i32.const 9612) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.\00") - (data $197 (i32.const 9708) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00c\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $198 (i32.const 9756) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00c\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $199 (i32.const 9804) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00l\00\00\00\00\00\00\00\00\00\00\00") - (data $200 (i32.const 9836) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00s\00h\00o\00u\00l\00d\00 \00r\00e\00a\00d\00 \00a\00n\00d\00 \00w\00r\00i\00t\00e\00 \00a\00c\00r\00o\00s\00s\00 \00p\00a\00g\00e\00s\00\00\00\00\00\00\00\00\00") - (data $201 (i32.const 9932) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\10\00\00\00\de\00\00\00\ad\00\00\00\be\00\00\00\ef\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $202 (i32.const 9980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") - (data $203 (i32.const 10012) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00J\00\00\001\007\003\00,\001\009\000\00,\002\003\009\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00\00\00") - (data $204 (i32.const 10108) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $205 (i32.const 10156) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00N\00\00\002\002\002\00,\001\007\003\00,\001\009\000\00,\002\003\009\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $206 (i32.const 10268) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00m\00\00\00\00\00\00\00\00\00\00\00") - (data $207 (i32.const 10300) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00`\00\00\00s\00h\00o\00u\00l\00d\00 \00a\00l\00l\00o\00w\00 \000\00-\00b\00y\00t\00e\00s\00 \00r\00e\00a\00d\00s\00 \00a\00n\00d\00 \00w\00r\00i\00t\00e\00s\00 \00e\00v\00e\00r\00y\00w\00h\00e\00r\00e\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $208 (i32.const 10428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00d\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $209 (i32.const 10476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00e\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $210 (i32.const 10524) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00n\00\00\00\00\00\00\00\00\00\00\00") - (data $211 (i32.const 10556) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00o\00\00\00\00\00\00\00\00\00\00\00") - (data $212 (i32.const 10588) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00p\00\00\00\00\00\00\00\00\00\00\00") - (data $213 (i32.const 10620) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00q\00\00\00\00\00\00\00\00\00\00\00") - (data $214 (i32.const 10652) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00r\00\00\00\00\00\00\00\00\00\00\00") - (data $215 (i32.const 10684) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $216 (i32.const 10716) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00t\00\00\00\00\00\00\00\00\00\00\00") - (data $217 (i32.const 10748) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00u\00\00\00\00\00\00\00\00\00\00\00") - (data $218 (i32.const 10780) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00v\00\00\00\00\00\00\00\00\00\00\00") - (data $219 (i32.const 10812) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00w\00\00\00\00\00\00\00\00\00\00\00") - (data $220 (i32.const 10844) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00x\00\00\00\00\00\00\00\00\00\00\00") - (data $221 (i32.const 10876) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00y\00\00\00\00\00\00\00\00\00\00\00") - (data $222 (i32.const 10908) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00z\00\00\00\00\00\00\00\00\00\00\00") - (data $223 (i32.const 10940) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00{\00\00\00\00\00\00\00\00\00\00\00") - (data $224 (i32.const 10972) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00|\00\00\00\00\00\00\00\00\00\00\00") - (data $225 (i32.const 11004) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00}\00\00\00\00\00\00\00\00\00\00\00") - (data $226 (i32.const 11036) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00~\00\00\00\00\00\00\00\00\00\00\00") - (data $227 (i32.const 11068) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\7f\00\00\00\00\00\00\00\00\00\00\00") - (data $228 (i32.const 11100) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\80\00\00\00\00\00\00\00\00\00\00\00") - (data $229 (i32.const 11132) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\81\00\00\00\00\00\00\00\00\00\00\00") - (data $230 (i32.const 11164) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\82\00\00\00\00\00\00\00\00\00\00\00") - (data $231 (i32.const 11196) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\83\00\00\00\00\00\00\00\00\00\00\00") - (data $232 (i32.const 11228) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\84\00\00\00\00\00\00\00\00\00\00\00") - (data $233 (i32.const 11260) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\85\00\00\00\00\00\00\00\00\00\00\00") - (data $234 (i32.const 11292) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\86\00\00\00\00\00\00\00\00\00\00\00") - (data $235 (i32.const 11324) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\87\00\00\00\00\00\00\00\00\00\00\00") - (data $236 (i32.const 11356) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\88\00\00\00\00\00\00\00\00\00\00\00") - (data $237 (i32.const 11388) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\89\00\00\00\00\00\00\00\00\00\00\00") - (data $238 (i32.const 11420) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8a\00\00\00\00\00\00\00\00\00\00\00") - (data $239 (i32.const 11452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8b\00\00\00\00\00\00\00\00\00\00\00") - (data $240 (i32.const 11484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8c\00\00\00\00\00\00\00\00\00\00\00") - (data $241 (i32.const 11516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8d\00\00\00\00\00\00\00\00\00\00\00") - (data $242 (i32.const 11548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8e\00\00\00\00\00\00\00\00\00\00\00") - (data $243 (i32.const 11580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8f\00\00\00\00\00\00\00\00\00\00\00") - (data $244 (i32.const 11612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\90\00\00\00\00\00\00\00\00\00\00\00") - (data $245 (i32.const 11644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\91\00\00\00\00\00\00\00\00\00\00\00") - (data $246 (i32.const 11676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\92\00\00\00\00\00\00\00\00\00\00\00") - (data $247 (i32.const 11708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\93\00\00\00\00\00\00\00\00\00\00\00") - (data $248 (i32.const 11740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\94\00\00\00\00\00\00\00\00\00\00\00") - (data $249 (i32.const 11772) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\95\00\00\00\00\00\00\00\00\00\00\00") - (data $250 (i32.const 11804) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\96\00\00\00\00\00\00\00\00\00\00\00") - (data $251 (i32.const 11836) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\97\00\00\00\00\00\00\00\00\00\00\00") - (data $252 (i32.const 11868) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\98\00\00\00\00\00\00\00\00\00\00\00") - (data $253 (i32.const 11900) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\99\00\00\00\00\00\00\00\00\00\00\00") - (data $254 (i32.const 11932) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9a\00\00\00\00\00\00\00\00\00\00\00") - (data $255 (i32.const 11964) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9b\00\00\00\00\00\00\00\00\00\00\00") - (data $256 (i32.const 11996) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") - (data $257 (i32.const 12028) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") - (data $258 (i32.const 12060) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9e\00\00\00\00\00\00\00\00\00\00\00") - (data $259 (i32.const 12092) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9f\00\00\00\00\00\00\00\00\00\00\00") - (data $260 (i32.const 12124) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a0\00\00\00\00\00\00\00\00\00\00\00") - (data $261 (i32.const 12156) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a1\00\00\00\00\00\00\00\00\00\00\00") - (data $262 (i32.const 12188) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a2\00\00\00\00\00\00\00\00\00\00\00") - (data $263 (i32.const 12220) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a3\00\00\00\00\00\00\00\00\00\00\00") - (data $264 (i32.const 12252) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a4\00\00\00\00\00\00\00\00\00\00\00") - (data $265 (i32.const 12284) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a5\00\00\00\00\00\00\00\00\00\00\00") - (data $266 (i32.const 12316) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a6\00\00\00\00\00\00\00\00\00\00\00") - (data $267 (i32.const 12348) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a7\00\00\00\00\00\00\00\00\00\00\00") - (data $268 (i32.const 12380) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a8\00\00\00\00\00\00\00\00\00\00\00") - (data $269 (i32.const 12412) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a9\00\00\00\00\00\00\00\00\00\00\00") - (data $270 (i32.const 12444) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\aa\00\00\00\00\00\00\00\00\00\00\00") - (data $271 (i32.const 12476) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ab\00\00\00\00\00\00\00\00\00\00\00") - (data $272 (i32.const 12508) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ac\00\00\00\00\00\00\00\00\00\00\00") - (data $273 (i32.const 12540) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ad\00\00\00\00\00\00\00\00\00\00\00") - (data $274 (i32.const 12572) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ae\00\00\00\00\00\00\00\00\00\00\00") - (data $275 (i32.const 12604) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\af\00\00\00\00\00\00\00\00\00\00\00") - (data $276 (i32.const 12636) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b0\00\00\00\00\00\00\00\00\00\00\00") - (data $277 (i32.const 12668) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b1\00\00\00\00\00\00\00\00\00\00\00") - (data $278 (i32.const 12700) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b2\00\00\00\00\00\00\00\00\00\00\00") - (data $279 (i32.const 12732) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b3\00\00\00\00\00\00\00\00\00\00\00") - (data $280 (i32.const 12764) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b4\00\00\00\00\00\00\00\00\00\00\00") - (data $281 (i32.const 12796) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00\901\00\00\b01\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d01\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d0)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p/\00\00\90/\00\00\b0/\00\00\d0/\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00P)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p)\00\00\f0)\00\00\10*\00\000*\00\00P*\00\00p*\00\00\90*\00\00\b0*\00\00\d0*\00\00\f0/\00\00\100\00\0000\00\00P0\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p0\00\00\900\00\00\b00\00\00\d00\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\90)\00\00@\15\00\00`\15\00\00\80\15\00\00\a0\15\00\00\c0\15\00\00\e0\15\00\00\00\16\00\00 \16\00\00@\16\00\00`\16\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d0+\00\00\f01\00\00\c0\05\00\00\e0\05\00\00\00\06\00\00 \06\00\00@\06\00\00`\06\00\00\80\06\00\00\a0\06\00\00\c0\06\00\00\e0\06\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\f00\00\00\101\00\0001\00\00P1\00\00\f0*\00\00\10+\00\000+\00\00P+\00\00p+\00\00\90+\00\00\b0+\00\00@\1a\00\00P\18\00\00p\18\00\00\90\18\00\00`\1a\00\00p,\00\00\90,\00\000-\00\00P-\00\00p-\00\00\80\1a\00\00\b0,\00\00\d0,\00\00\90-\00\00\b0-\00\00\d0-\00\00\f0+\00\00\10,\00\00\a0\1a\00\00\c0\1a\00\00\f0-\00\00\10.\00\000.\00\00\e0\1a\00\00P.\00\00p.\00\00\90.\00\00\e0\1e\00\00\00\1f\00\00 \1f\00\00@\1f\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\80\16\00\00\a0\16\00\00\c0\16\00\00\e0\16\00\00\00\17\00\00 \17\00\00p1\00\00p1\00\00p1\00\00p1\00\00\b0)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\00\1b\00\00 \1b\00\00@\1b\00\00`\1b\00\00\80\1b\00\00\a0\1b\00\00\c0\1b\00\00\b0.\00\00\d0.\00\00\f0.\00\00\e0\1b\00\00\00\1c\00\00 \1c\00\00@\1c\00\00`\1c\00\00\80\1c\00\00\a0\1c\00\00\10/\00\000/\00\00P/\00\00\b0\18\00\00\d0\18\00\00\f0\18\00\00\c0\1c\00\00\e0\1c\00\00\00\1d\00\00\f0,\00\00\10-\00\000,\00\00P,\00\00`\1f\00\00\80\1f\00\00\a0\1f\00\00\c0\1f\00\00\10\19\00\000\19\00\00P\19\00\00 \1d\00\00@\1d\00\00`\1d\00\00\80\1d\00\00") - (data $282 (i32.const 13740) ",\00\00\00\00\00\00\00\00\00\00\00!\00\00\00\10\00\00\00\102\00\00\102\00\00\9c\03\00\00\e7\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $283 (i32.const 13788) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80\00\00\00\00") - (data $284 (i32.const 13820) ",\00\00\00\00\00\00\00\00\00\00\00\"\00\00\00\10\00\00\00\f05\00\00\f05\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $285 (i32.const 13868) "\1c\00\00\00\00\00\00\00\00\00\00\00#\00\00\00\08\00\00\00\b5\00\00\00\00\00\00\00\00\00\00\00") - (data $286 (i32.const 13900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $287 (i32.const 13948) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00S\00B\00R\00K\00\00\00\00\00") - (data $288 (i32.const 13980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00T\00R\00A\00P\00\00\00\00\00") - (data $289 (i32.const 14012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H\00\00\00\00\00\00\00") - (data $290 (i32.const 14060) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I\00") - (data $291 (i32.const 14092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00") - (data $292 (i32.const 14140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008\00\00\00\00\00") - (data $293 (i32.const 14188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006\00\00\00") - (data $294 (i32.const 14236) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002\00\00\00") - (data $295 (i32.const 14284) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004\00\00\00") - (data $296 (i32.const 14332) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00J\00U\00M\00P\00\00\00\00\00") - (data $297 (i32.const 14364) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $298 (i32.const 14412) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $299 (i32.const 14460) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $300 (i32.const 14508) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $301 (i32.const 14556) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $302 (i32.const 14604) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $303 (i32.const 14652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $304 (i32.const 14700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $305 (i32.const 14748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $306 (i32.const 14796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $307 (i32.const 14844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") - (data $308 (i32.const 14892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $309 (i32.const 14940) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $310 (i32.const 14988) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $311 (i32.const 15052) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") - (data $312 (i32.const 15116) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $313 (i32.const 15180) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $314 (i32.const 15244) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00\00\00") - (data $315 (i32.const 15292) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M\00\00\00") - (data $316 (i32.const 15340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M\00\00\00") - (data $317 (i32.const 15388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $318 (i32.const 15452) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $319 (i32.const 15516) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $320 (i32.const 15580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $321 (i32.const 15644) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $322 (i32.const 15708) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $323 (i32.const 15772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $324 (i32.const 15836) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $325 (i32.const 15900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $326 (i32.const 15948) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $327 (i32.const 16012) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $328 (i32.const 16076) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00") - (data $329 (i32.const 16140) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00") - (data $330 (i32.const 16204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00") - (data $331 (i32.const 16268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00") - (data $332 (i32.const 16332) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008\00\00\00") - (data $333 (i32.const 16380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") - (data $334 (i32.const 16428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") - (data $335 (i32.const 16476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S\00\00\00") - (data $336 (i32.const 16524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00") - (data $337 (i32.const 16572) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006\00\00\00") - (data $338 (i32.const 16620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002\00\00\00") - (data $339 (i32.const 16668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004\00\00\00") - (data $340 (i32.const 16716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00") - (data $341 (i32.const 16764) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008\00\00\00\00\00\00\00") - (data $342 (i32.const 16812) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00") - (data $343 (i32.const 16860) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006\00\00\00\00\00") - (data $344 (i32.const 16908) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00") - (data $345 (i32.const 16956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002\00\00\00\00\00") - (data $346 (i32.const 17004) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00") - (data $347 (i32.const 17052) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") - (data $348 (i32.const 17100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $349 (i32.const 17148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $350 (i32.const 17196) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M\00") - (data $351 (i32.const 17228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") - (data $352 (i32.const 17276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") - (data $353 (i32.const 17324) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") - (data $354 (i32.const 17372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $355 (i32.const 17420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $356 (i32.const 17468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $357 (i32.const 17516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00") - (data $358 (i32.const 17564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") - (data $359 (i32.const 17612) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") - (data $360 (i32.const 17660) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $361 (i32.const 17724) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $362 (i32.const 17788) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $363 (i32.const 17852) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") - (data $364 (i32.const 17900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") - (data $365 (i32.const 17948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") - (data $366 (i32.const 17996) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") - (data $367 (i32.const 18044) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $368 (i32.const 18092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $369 (i32.const 18140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $370 (i32.const 18188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00") - (data $371 (i32.const 18236) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $372 (i32.const 18300) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $373 (i32.const 18364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $374 (i32.const 18428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00\00\00\00\00") - (data $375 (i32.const 18476) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $376 (i32.const 18540) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00\00\00\00\00") - (data $377 (i32.const 18588) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $378 (i32.const 18652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00\00\00\00\00\00\00\00\00\00\00") - (data $379 (i32.const 18700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00\00\00\00\00\00\00\00\00\00\00") - (data $380 (i32.const 18748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00\00\00\00\00\00\00") - (data $381 (i32.const 18796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00\00\00\00\00\00\00") - (data $382 (i32.const 18844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00\00\00\00\00\00\00") - (data $383 (i32.const 18892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00\00\00\00\00\00\00") - (data $384 (i32.const 18940) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00") - (data $385 (i32.const 19004) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002\00") - (data $386 (i32.const 19036) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002\00") - (data $387 (i32.const 19068) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002\00") - (data $388 (i32.const 19100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $389 (i32.const 19148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $390 (i32.const 19196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $391 (i32.const 19244) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $392 (i32.const 19292) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $393 (i32.const 19340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $394 (i32.const 19388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $395 (i32.const 19436) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004\00") - (data $396 (i32.const 19468) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004\00") - (data $397 (i32.const 19500) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004\00") - (data $398 (i32.const 19532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $399 (i32.const 19580) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $400 (i32.const 19628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $401 (i32.const 19676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $402 (i32.const 19724) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $403 (i32.const 19772) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $404 (i32.const 19820) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $405 (i32.const 19868) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00A\00N\00D\00\00\00\00\00\00\00") - (data $406 (i32.const 19900) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00X\00O\00R\00\00\00\00\00\00\00") - (data $407 (i32.const 19932) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00O\00R\00\00\00\00\00\00\00\00\00") - (data $408 (i32.const 19964) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S\00\00\00") - (data $409 (i32.const 20012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U\00\00\00") - (data $410 (i32.const 20060) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U\00\00\00") - (data $411 (i32.const 20108) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $412 (i32.const 20156) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $413 (i32.const 20204) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $414 (i32.const 20252) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $415 (i32.const 20300) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $416 (i32.const 20348) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $417 (i32.const 20396) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $418 (i32.const 20444) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $419 (i32.const 20492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $420 (i32.const 20540) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V\00") - (data $421 (i32.const 20572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00X\00N\00O\00R\00\00\00\00\00") - (data $422 (i32.const 20604) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00A\00X\00\00\00\00\00\00\00") - (data $423 (i32.const 20636) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00A\00X\00_\00U\00\00\00") - (data $424 (i32.const 20668) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00I\00N\00\00\00\00\00\00\00") - (data $425 (i32.const 20700) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00I\00N\00_\00U\00\00\00") - (data $426 (i32.const 20732) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00s\00h\00o\00u\00l\00d\00 \00p\00a\00r\00s\00e\00 \00p\00a\00c\00k\00e\00d\00 \00m\00a\00s\00k\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00\00\00\00\00\00\00\00\00") - (data $427 (i32.const 20828) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\18\00\00\00\00\00\00\00\00\000@\00\00\00\00\00\00`@\00\00\00\00\00\00o@\00\00\00\00") - (data $428 (i32.const 20876) "l\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00T\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\n\00\00\00\t\00\00\00\08\00\00\00\07\00\00\00\06\00\00\00\05\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $429 (i32.const 20988) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00l\00e\00n\00g\00t\00h\00 \00@\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $430 (i32.const 21036) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b6\00\00\00\00\00\00\00\00\00\00\00") - (data $431 (i32.const 21068) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00X\00\00\00s\00h\00o\00u\00l\00d\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00 \00s\00k\00i\00p\00p\00i\00n\00g\00 \00m\00o\00r\00e\00 \00t\00h\00a\00n\00 \002\004\00 \00b\00y\00t\00e\00s\00\00\00\00\00") - (data $432 (i32.const 21180) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00`@\00\00\00\00\00\00\00\00\00\00\00\00") - (data $433 (i32.const 21244) "\9c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\80\00\00\00\00\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\18\00\00\00\17\00\00\00\16\00\00\00\15\00\00\00\14\00\00\00\13\00\00\00\12\00\00\00\11\00\00\00\10\00\00\00\0f\00\00\00\0e\00\00\00\r\00\00\00\0c\00\00\00\0b\00\00\00\n\00\00\00\t\00\00\00\08\00\00\00\07\00\00\00\06\00\00\00\05\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $434 (i32.const 21404) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b7\00\00\00\00\00\00\00\00\00\00\00") - (data $435 (i32.const 21436) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00B\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00\00\00\00\00\00\00\00\00\00\00") - (data $436 (i32.const 21532) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\00\00\00\00\00\00\00") - (data $437 (i32.const 21596) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $438 (i32.const 21724) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") - (data $439 (i32.const 21756) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") - (data $440 (i32.const 21788) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") - (data $441 (i32.const 21820) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") - (data $442 (i32.const 21852) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b8\00\00\00\00\00\00\00\00\00\00\00") - (data $443 (i32.const 21884) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00p\00o\00s\00i\00t\00i\00v\00e\00 \00b\00o\00u\00n\00d\00e\00d\00 \00b\00y\00 \00s\00k\00i\00p\00") - (data $444 (i32.const 21980) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\10\00\00\00\00\00\00\00\00\00\14@\00\00\00\00\00\00\14@\00\00\00\00\00\00\00\00\00\00\00\00") - (data $445 (i32.const 22028) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b9\00\00\00\00\00\00\00\00\00\00\00") - (data $446 (i32.const 22060) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00b\00l\00o\00b\00 \00p\00r\00o\00g\00r\00a\00m\00\00\00") - (data $447 (i32.const 22124) "\\\01\00\00\00\00\00\00\00\00\00\00\01\00\00\00H\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\80@@\00\00\00\00\00\80I@\00\00\00\00\00\00 @\00\00\00\00\00\00\f0?\00\00\00\00\00\80I@\00\00\00\00\00\00\"@\00\00\00\00\00\00\f0?\00\00\00\00\00\00D@\00\00\00\00\00\00\08@\00\00\00\00\00\00\00\00\00\00\00\00\00\a0b@\00\00\00\00\00\c0]@\00\00\00\00\00\e0o@\00\00\00\00\00@T@\00\00\00\00\00\00\1c@\00\00\00\00\00\00(@\00\00\00\00\00\00Y@\00\00\00\00\00@a@\00\00\00\00\00\00i@\00\00\00\00\00\00c@\00\00\00\00\00\00 @\00\00\00\00\00\00Y@\00\00\00\00\00 e@\00\00\00\00\00\00D@\00\00\00\00\00`n@\00\00\00\00\00\00Y@\00\00\00\00\00\e0`@\00\00\00\00\00\80I@\00\00\00\00\00\00 @\00\00\00\00\00\80I@\00\00\00\00\00\00\"@\00\00\00\00\00\00\f0?\00\00\00\00\00\00I@\00\00\00\00\00\00\00\00\00\00\00\00\00@R@\00\00\00\00\00`b@\00\00\00\00\00\80T@\00\00\00\00\00\a0j@\00\00\00\00\00\00\00\00\00\00\00\00") - (data $448 (i32.const 22476) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 \00\00\00") - (data $449 (i32.const 22556) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $450 (i32.const 22604) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\e0W\00\00\00\00\00\000X\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $451 (i32.const 22652) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $452 (i32.const 22716) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 \00\00\00\00\00\00\00\00\00") - (data $453 (i32.const 22828) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $454 (i32.const 22876) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\d0X\00\00\00\00\00\00@Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $455 (i32.const 22924) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00a\00s\00k\00[\00\00\00") - (data $456 (i32.const 22956) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00,\00 \00\00\00\00\00\00\00\00\00") - (data $457 (i32.const 22988) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") - (data $458 (i32.const 23020) "\ec\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\d2\00\00\00M\00a\00s\00k\00[\000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \000\00,\00 \001\00,\00 \00]\00\00\00\00\00\00\00\00\00\00\00") - (data $459 (i32.const 23260) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00\00\00\00\00\00\00\00\00") - (data $460 (i32.const 23308) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00-\00>\00 \00\00\00\00\00") - (data $461 (i32.const 23340) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00 [\00\00\00\00\00\00\c0Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $462 (i32.const 23388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00]\00\00\00\00\00\00\00") - (data $463 (i32.const 23436) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\00\00\00\00\00") - (data $464 (i32.const 23484) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00s\00t\00a\00r\00t\00\00\00") - (data $465 (i32.const 23516) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00e\00n\00d\00\00\00\00\00\00\00") - (data $466 (i32.const 23548) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00 [\00\00\00\00\00\00\c0Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $467 (i32.const 23596) ",\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\01\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \006\00 \00-\00>\00 \00e\00n\00d\00,\00 \008\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \009\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \001\002\00 \00-\00>\00 \00e\00n\00d\00,\00 \001\005\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \002\002\00 \00-\00>\00 \00e\00n\00d\00,\00 \002\004\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \003\000\00 \00-\00>\00 \00e\00n\00d\00,\00 \003\001\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \00]\00\00\00\00\00\00\00\00\00\00\00") - (data $468 (i32.const 23900) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\ba\00\00\00\00\00\00\00\00\00\00\00") - (data $469 (i32.const 23932) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00j\00\00\00s\00h\00o\00u\00l\00d\00 \00c\00o\00n\00s\00t\00r\00u\00c\00t\00 \00b\00a\00s\00i\00c\00 \00b\00l\00o\00c\00k\00s\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00 \00b\00a\00s\00e\00d\00 \00o\00n\00 \00s\00k\00i\00p\00\00\00") - (data $470 (i32.const 24060) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00Z\00\00\00O\00p\00c\00o\00d\00e\00 \00n\00o\00t\00 \00f\00o\00u\00n\00d\00 \00i\00n\00 \00R\00U\00N\00 \00t\00a\00b\00l\00e\00 \00f\00o\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00\00\00") - (data $471 (i32.const 24172) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00e\00s\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $472 (i32.const 24252) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00`@\00\00\00\00\00\00\00\00\00\00\00\00") - (data $473 (i32.const 24316) "\0c\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\f6\00\00\00M\00a\00s\00k\00[\000\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\004\00,\00 \002\003\00,\00 \002\002\00,\00 \002\001\00,\00 \002\000\00,\00 \001\009\00,\00 \001\008\00,\00 \001\007\00,\00 \001\006\00,\00 \001\005\00,\00 \001\004\00,\00 \001\003\00,\00 \001\002\00,\00 \001\001\00,\00 \001\000\00,\00 \009\00,\00 \008\00,\00 \007\00,\00 \006\00,\00 \005\00,\00 \004\00,\00 \003\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \00]\00\00\00\00\00\00\00") - (data $474 (i32.const 24588) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00h\00\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \002\006\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \003\001\00 \00-\00>\00 \00e\00n\00d\00,\00 \00]\00\00\00\00\00") - (data $475 (i32.const 24716) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bb\00\00\00\00\00\00\00\00\00\00\00") - (data $476 (i32.const 24748) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00s\00h\00o\00u\00l\00d\00 \00p\00a\00r\00s\00e\00 \00j\00u\00m\00p\00 \00t\00a\00b\00l\00e\00 \00w\00i\00t\00h\00 \00l\00a\00r\00g\00e\00 \00n\00u\00m\00b\00e\00r\00s\00\00\00\00\00\00\00\00\00") - (data $477 (i32.const 24860) "\0c\01\00\00\00\00\00\00\00\00\00\00\01\00\00\00\f0\00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $478 (i32.const 25132) "\cc\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\b8\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\000\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \001\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \002\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \00]\00\00\00\00\00") - (data $479 (i32.const 25340) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bc\00\00\00\00\00\00\00\00\00\00\00") - (data $480 (i32.const 25372) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00<\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00s\00t\00a\00n\00d\00a\00r\00d\00 \00p\00r\00o\00g\00r\00a\00m\00") - (data $481 (i32.const 25452) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\1c\00\00\00\04\00\00\02\00\00\03\00 \00\00\ab\cd\ef\01\124\07\00\00\00\00\00\03\c8\87\t\01") - (data $482 (i32.const 25500) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\03\00\00\00\124V\00\00\00\00\00\00\00\00\00") - (data $483 (i32.const 25532) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00A\00r\00g\00u\00m\00e\00n\00t\00s\00 \00l\00e\00n\00g\00t\00h\00 \00t\00o\00o\00 \00b\00i\00g\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $484 (i32.const 25612) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00s\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $485 (i32.const 25676) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") - (data $486 (i32.const 25804) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00\00\00\00\00\00\00") - (data $487 (i32.const 25884) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $488 (i32.const 25948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \00\00\00") - (data $489 (i32.const 25996) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00}\00\00\00\00\00\00\00\00\00") - (data $490 (i32.const 26028) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00\e0d\00\00\00\00\00\000e\00\00\00\00\00\00pe\00\00\00\00\00\00\a0e\00\00") - (data $491 (i32.const 26076) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $492 (i32.const 26140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00m\00a\00s\00k\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $493 (i32.const 26188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00\00\00") - (data $494 (i32.const 26236) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $495 (i32.const 26300) "<\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00$\00\00\00\f0e\00\00\00\00\00\000f\00\00\00\00\00\00`f\00\00\00\00\00\00\90f\00\00\00\00\00\00\a0e\00\00\00\00\00\00\00\00\00\00") - (data $496 (i32.const 26364) "\dc\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\c2\01\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \002\000\000\00,\001\003\005\00,\009\00,\00 \00m\00a\00s\00k\00:\00 \00M\00a\00s\00k\00[\000\00,\00 \002\00,\00 \001\00,\00 \00]\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00]\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \00]\00 \00}\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \007\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \004\002\009\004\009\000\001\007\006\000\00,\004\002\007\008\000\005\009\000\000\008\00,\000\00,\000\00,\000\00,\000\00,\000\00,\004\002\007\008\001\002\004\005\004\004\00,\003\00,\000\00,\000\00,\000\00,\000\00 \00}\00\00\00\00\00\00\00\00\00\00\00") - (data $497 (i32.const 26844) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bd\00\00\00\00\00\00\00\00\00\00\00") - (data $498 (i32.const 26876) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00b\00i\00t\00.\00t\00s\00") - (data $499 (i32.const 26908) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00>\00 \00\00\00\00\00\00\00\00\00") - (data $500 (i32.const 26940) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00>\00>\00>\00 \00") - (data $501 (i32.const 26972) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00<\00<\00<\00 \00") - (data $502 (i32.const 27004) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00\05\'\00\00\00\00\00\00\00\00") - (data $503 (i32.const 27036) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00pi\00\00\00\00\00\00\90i\00\00") - (data $504 (i32.const 27068) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00 \00 \00 \00\00\00\00\00") - (data $505 (i32.const 27100) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00=\d84\dd\00\00\00\00\00\00") - (data $506 (i32.const 27132) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00pi\00\00\00\00\00\00\f0i\00\00") - (data $507 (i32.const 27164) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00<\00 \00\00\00\00\00\00\00\00\00") - (data $508 (i32.const 27196) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\05\'\00\00\00\00\00\00\00\00\00\00") - (data $509 (i32.const 27228) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00=\d84\dd\00\00\00\00\00\00\00\00") - (data $510 (i32.const 27260) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $511 (i32.const 27292) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00/\00 \00\00\00\00\00\00\00") - (data $512 (i32.const 27324) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00\00\00\00\00\90j\00\00\00\00\00\00\b0j\00\00\00\00\00\00\90j\00\00\00\00\00\00") - (data $513 (i32.const 27372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00b\00r\00a\00n\00c\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $514 (i32.const 27420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00l\00o\00g\00i\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $515 (i32.const 27468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00m\00a\00t\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $516 (i32.const 27516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $517 (i32.const 27564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $518 (i32.const 27612) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00r\00o\00t\00.\00t\00s\00") - (data $519 (i32.const 27644) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00s\00p\00i\00.\00t\00s\00") - (data $520 (i32.const 27676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00\n\00\n\00T\00o\00t\00a\00l\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $521 (i32.const 27724) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00S\00o\00m\00e\00 \00t\00e\00s\00t\00s\00 \00f\00a\00i\00l\00e\00d\00.\00\00\00\00\00\00\00\00\00") - (data $522 (i32.const 27788) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00t\00e\00s\00t\00-\00r\00u\00n\00.\00t\00s\00\00\00\00\00") - (data $523 (i32.const 27856) "0\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\02A\00\00\02A\00\00\00\00\00\00\04A\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00A\00\00\00\02A\00\00B\00\00\00\00\00\00\00\02\01\00\00\00\00\00\00$\01\00\00\02\1a\00\00\02\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\t\00\00\00\00\00\00 \00\00\00\00\00\00\00") - (table $0 190 190 funcref) - (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/bit.test~anonymous|0 $start:assembly/instructions/bit.test~anonymous|1 $start:assembly/instructions/bit.test~anonymous|2 $start:assembly/instructions/bit.test~anonymous|3 $start:assembly/instructions/bit.test~anonymous|4 $start:assembly/instructions/bit.test~anonymous|5 $start:assembly/instructions/bit.test~anonymous|6 $start:assembly/instructions/bit.test~anonymous|7 $start:assembly/instructions/bit.test~anonymous|8 $start:assembly/instructions/bit.test~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/branch.test~anonymous|0 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/logic.test~anonymous|0 $start:assembly/instructions/logic.test~anonymous|1 $start:assembly/instructions/logic.test~anonymous|2 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/math.test~anonymous|0 $start:assembly/instructions/math.test~anonymous|1 $start:assembly/instructions/math.test~anonymous|2 $start:assembly/instructions/math.test~anonymous|3 $start:assembly/instructions/math.test~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/rot.test~anonymous|0 $start:assembly/instructions/rot.test~anonymous|1 $start:assembly/instructions/rot.test~anonymous|2 $start:assembly/instructions/rot.test~anonymous|3 $start:assembly/memory.test~anonymous|0 $start:assembly/memory.test~anonymous|1 $start:assembly/memory.test~anonymous|2 $start:assembly/memory.test~anonymous|3 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $start:assembly/program.test~anonymous|0 $start:assembly/program.test~anonymous|1 $start:assembly/program.test~anonymous|2 $start:assembly/program.test~anonymous|3 $start:assembly/program.test~anonymous|4 $start:assembly/program.test~anonymous|5 $start:assembly/program.test~anonymous|6 $start:assembly/spi.test~anonymous|0) - (export "runAllTests" (func $assembly/test-run/runAllTests)) - (export "memory" (memory $0)) - (start $~start) - (func $~lib/rt/itcms/Object#set:nextWithColor (param $this i32) (param $nextWithColor i32) - local.get $this - local.get $nextWithColor - i32.store offset=4 - ) - (func $~lib/rt/itcms/Object#set:prev (param $this i32) (param $prev i32) - local.get $this - local.get $prev - i32.store offset=8 - ) - (func $~lib/rt/itcms/initLazy (param $space i32) (result i32) - local.get $space - local.get $space - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $space - local.get $space - call $~lib/rt/itcms/Object#set:prev - local.get $space - return - ) - (func $~lib/rt/itcms/Object#get:nextWithColor (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/rt/itcms/Object#get:next (param $this i32) (result i32) - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.const -1 - i32.xor - i32.and - return - ) - (func $~lib/rt/itcms/Object#get:color (param $this i32) (result i32) - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.and - return - ) - (func $~lib/rt/itcms/visitRoots (param $cookie i32) - (local $pn i32) - (local $iter i32) - local.get $cookie - call $~lib/rt/__visit_globals - global.get $~lib/rt/itcms/pinSpace - local.set $pn - local.get $pn - call $~lib/rt/itcms/Object#get:next - local.set $iter - loop $while-continue|0 - local.get $iter - local.get $pn - i32.ne - if - i32.const 1 - drop - local.get $iter - call $~lib/rt/itcms/Object#get:color - i32.const 3 - i32.eq - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 160 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $iter - i32.const 20 - i32.add - local.get $cookie - call $~lib/rt/__visit_members - local.get $iter - call $~lib/rt/itcms/Object#get:next - local.set $iter - br $while-continue|0 - end - end - ) - (func $~lib/rt/itcms/Object#set:color (param $this i32) (param $color i32) - local.get $this - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $color - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - ) - (func $~lib/rt/itcms/Object#get:prev (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/rt/itcms/Object#set:next (param $this i32) (param $obj i32) - local.get $this - local.get $obj - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.and - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - ) - (func $~lib/rt/itcms/Object#unlink (param $this i32) - (local $next i32) - (local $prev i32) - local.get $this - call $~lib/rt/itcms/Object#get:next - local.set $next - local.get $next - i32.const 0 - i32.eq - if - i32.const 1 - drop - local.get $this - call $~lib/rt/itcms/Object#get:prev - i32.const 0 - i32.eq - if (result i32) - local.get $this - global.get $~lib/memory/__heap_base - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 128 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - return - end - local.get $this - call $~lib/rt/itcms/Object#get:prev - local.set $prev - i32.const 1 - drop - local.get $prev - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 132 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $next - local.get $prev - call $~lib/rt/itcms/Object#set:prev - local.get $prev - local.get $next - call $~lib/rt/itcms/Object#set:next - ) - (func $~lib/rt/itcms/Object#get:rtId (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/shared/typeinfo/Typeinfo#get:flags (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/__typeinfo (param $id i32) (result i32) - (local $ptr i32) - global.get $~lib/rt/__rtti_base - local.set $ptr - local.get $id - local.get $ptr - i32.load - i32.gt_u - if - i32.const 480 - i32.const 544 - i32.const 21 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $ptr - i32.const 4 - i32.add - local.get $id - i32.const 4 - i32.mul - i32.add - call $~lib/shared/typeinfo/Typeinfo#get:flags - return - ) - (func $~lib/rt/itcms/Object#get:isPointerfree (param $this i32) (result i32) - (local $rtId i32) - local.get $this - call $~lib/rt/itcms/Object#get:rtId - local.set $rtId - local.get $rtId - i32.const 2 - i32.le_u - if (result i32) - i32.const 1 - else - local.get $rtId - call $~lib/rt/__typeinfo - i32.const 32 - i32.and - i32.const 0 - i32.ne - end - return - ) - (func $~lib/rt/itcms/Object#linkTo (param $this i32) (param $list i32) (param $withColor i32) - (local $prev i32) - local.get $list - call $~lib/rt/itcms/Object#get:prev - local.set $prev - local.get $this - local.get $list - local.get $withColor - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $this - local.get $prev - call $~lib/rt/itcms/Object#set:prev - local.get $prev - local.get $this - call $~lib/rt/itcms/Object#set:next - local.get $list - local.get $this - call $~lib/rt/itcms/Object#set:prev - ) - (func $~lib/rt/itcms/Object#makeGray (param $this i32) - (local $1 i32) - local.get $this - global.get $~lib/rt/itcms/iter - i32.eq - if - local.get $this - call $~lib/rt/itcms/Object#get:prev - local.tee $1 - i32.eqz - if (result i32) - i32.const 0 - i32.const 352 - i32.const 148 - i32.const 30 - call $~lib/builtins/abort - unreachable - else - local.get $1 - end - global.set $~lib/rt/itcms/iter - end - local.get $this - call $~lib/rt/itcms/Object#unlink - local.get $this - global.get $~lib/rt/itcms/toSpace - local.get $this - call $~lib/rt/itcms/Object#get:isPointerfree - if (result i32) - global.get $~lib/rt/itcms/white - i32.eqz - else - i32.const 2 - end - call $~lib/rt/itcms/Object#linkTo - ) - (func $~lib/rt/itcms/__visit (param $ptr i32) (param $cookie i32) - (local $obj i32) - local.get $ptr - i32.eqz - if - return - end - local.get $ptr - i32.const 20 - i32.sub - local.set $obj - i32.const 0 - drop - local.get $obj - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eq - if - local.get $obj - call $~lib/rt/itcms/Object#makeGray - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.add - global.set $~lib/rt/itcms/visitCount - end - ) - (func $~lib/rt/itcms/visitStack (param $cookie i32) - (local $ptr i32) - global.get $~lib/memory/__stack_pointer - local.set $ptr - loop $while-continue|0 - local.get $ptr - global.get $~lib/memory/__heap_base - i32.lt_u - if - local.get $ptr - i32.load - local.get $cookie - call $~lib/rt/itcms/__visit - local.get $ptr - i32.const 4 - i32.add - local.set $ptr - br $while-continue|0 - end - end - ) - (func $~lib/rt/common/BLOCK#get:mmInfo (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/itcms/Object#get:size (param $this i32) (result i32) - i32.const 4 - local.get $this - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - return - ) - (func $~lib/rt/tlsf/Root#set:flMap (param $this i32) (param $flMap i32) - local.get $this - local.get $flMap - i32.store - ) - (func $~lib/rt/common/BLOCK#set:mmInfo (param $this i32) (param $mmInfo i32) - local.get $this - local.get $mmInfo - i32.store - ) - (func $~lib/rt/tlsf/Block#set:prev (param $this i32) (param $prev i32) - local.get $this - local.get $prev - i32.store offset=4 - ) - (func $~lib/rt/tlsf/Block#set:next (param $this i32) (param $next i32) - local.get $this - local.get $next - i32.store offset=8 - ) - (func $~lib/rt/tlsf/Block#get:prev (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/rt/tlsf/Block#get:next (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/rt/tlsf/Root#get:flMap (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/tlsf/removeBlock (param $root i32) (param $block i32) - (local $blockInfo i32) - (local $size i32) - (local $fl i32) - (local $sl i32) - (local $6 i32) - (local $7 i32) - (local $boundedSize i32) - (local $prev i32) - (local $next i32) - (local $root|11 i32) - (local $fl|12 i32) - (local $sl|13 i32) - (local $root|14 i32) - (local $fl|15 i32) - (local $sl|16 i32) - (local $head i32) - (local $root|18 i32) - (local $fl|19 i32) - (local $slMap i32) - (local $root|21 i32) - (local $fl|22 i32) - (local $slMap|23 i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $blockInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 268 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.set $size - i32.const 1 - drop - local.get $size - i32.const 12 - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 270 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - local.tee $6 - i32.const 1073741820 - local.tee $7 - local.get $6 - local.get $7 - i32.lt_u - select - local.set $boundedSize - i32.const 31 - local.get $boundedSize - i32.clz - i32.sub - local.set $fl - local.get $boundedSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 284 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $block - call $~lib/rt/tlsf/Block#get:prev - local.set $prev - local.get $block - call $~lib/rt/tlsf/Block#get:next - local.set $next - local.get $prev - if - local.get $prev - local.get $next - call $~lib/rt/tlsf/Block#set:next - end - local.get $next - if - local.get $next - local.get $prev - call $~lib/rt/tlsf/Block#set:prev - end - local.get $block - block $~lib/rt/tlsf/GETHEAD|inlined.0 (result i32) - local.get $root - local.set $root|11 - local.get $fl - local.set $fl|12 - local.get $sl - local.set $sl|13 - local.get $root|11 - local.get $fl|12 - i32.const 4 - i32.shl - local.get $sl|13 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.0 - end - i32.eq - if - local.get $root - local.set $root|14 - local.get $fl - local.set $fl|15 - local.get $sl - local.set $sl|16 - local.get $next - local.set $head - local.get $root|14 - local.get $fl|15 - i32.const 4 - i32.shl - local.get $sl|16 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head - i32.store offset=96 - local.get $next - i32.eqz - if - block $~lib/rt/tlsf/GETSL|inlined.0 (result i32) - local.get $root - local.set $root|18 - local.get $fl - local.set $fl|19 - local.get $root|18 - local.get $fl|19 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.0 - end - local.set $slMap - local.get $root - local.set $root|21 - local.get $fl - local.set $fl|22 - local.get $slMap - i32.const 1 - local.get $sl - i32.shl - i32.const -1 - i32.xor - i32.and - local.tee $slMap - local.set $slMap|23 - local.get $root|21 - local.get $fl|22 - i32.const 2 - i32.shl - i32.add - local.get $slMap|23 - i32.store offset=4 - local.get $slMap - i32.eqz - if - local.get $root - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 1 - local.get $fl - i32.shl - i32.const -1 - i32.xor - i32.and - call $~lib/rt/tlsf/Root#set:flMap - end - end - end - ) - (func $~lib/rt/tlsf/insertBlock (param $root i32) (param $block i32) - (local $blockInfo i32) - (local $block|3 i32) - (local $right i32) - (local $rightInfo i32) - (local $block|6 i32) - (local $block|7 i32) - (local $left i32) - (local $leftInfo i32) - (local $size i32) - (local $fl i32) - (local $sl i32) - (local $13 i32) - (local $14 i32) - (local $boundedSize i32) - (local $root|16 i32) - (local $fl|17 i32) - (local $sl|18 i32) - (local $head i32) - (local $root|20 i32) - (local $fl|21 i32) - (local $sl|22 i32) - (local $head|23 i32) - (local $root|24 i32) - (local $fl|25 i32) - (local $root|26 i32) - (local $fl|27 i32) - (local $slMap i32) - i32.const 1 - drop - local.get $block - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 201 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $blockInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 203 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETRIGHT|inlined.0 (result i32) - local.get $block - local.set $block|3 - local.get $block|3 - i32.const 4 - i32.add - local.get $block|3 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.0 - end - local.set $right - local.get $right - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $rightInfo - local.get $rightInfo - i32.const 1 - i32.and - if - local.get $root - local.get $right - call $~lib/rt/tlsf/removeBlock - local.get $block - local.get $blockInfo - i32.const 4 - i32.add - local.get $rightInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - local.tee $blockInfo - call $~lib/rt/common/BLOCK#set:mmInfo - block $~lib/rt/tlsf/GETRIGHT|inlined.1 (result i32) - local.get $block - local.set $block|6 - local.get $block|6 - i32.const 4 - i32.add - local.get $block|6 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.1 - end - local.set $right - local.get $right - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $rightInfo - end - local.get $blockInfo - i32.const 2 - i32.and - if - block $~lib/rt/tlsf/GETFREELEFT|inlined.0 (result i32) - local.get $block - local.set $block|7 - local.get $block|7 - i32.const 4 - i32.sub - i32.load - br $~lib/rt/tlsf/GETFREELEFT|inlined.0 - end - local.set $left - local.get $left - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $leftInfo - i32.const 1 - drop - local.get $leftInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 221 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $root - local.get $left - call $~lib/rt/tlsf/removeBlock - local.get $left - local.set $block - local.get $block - local.get $leftInfo - i32.const 4 - i32.add - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - local.tee $blockInfo - call $~lib/rt/common/BLOCK#set:mmInfo - end - local.get $right - local.get $rightInfo - i32.const 2 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.set $size - i32.const 1 - drop - local.get $size - i32.const 12 - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 233 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - i32.const 1 - drop - local.get $block - i32.const 4 - i32.add - local.get $size - i32.add - local.get $right - i32.eq - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 234 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $right - i32.const 4 - i32.sub - local.get $block - i32.store - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - local.tee $13 - i32.const 1073741820 - local.tee $14 - local.get $13 - local.get $14 - i32.lt_u - select - local.set $boundedSize - i32.const 31 - local.get $boundedSize - i32.clz - i32.sub - local.set $fl - local.get $boundedSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 251 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETHEAD|inlined.1 (result i32) - local.get $root - local.set $root|16 - local.get $fl - local.set $fl|17 - local.get $sl - local.set $sl|18 - local.get $root|16 - local.get $fl|17 - i32.const 4 - i32.shl - local.get $sl|18 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.1 - end - local.set $head - local.get $block - i32.const 0 - call $~lib/rt/tlsf/Block#set:prev - local.get $block - local.get $head - call $~lib/rt/tlsf/Block#set:next - local.get $head - if - local.get $head - local.get $block - call $~lib/rt/tlsf/Block#set:prev - end - local.get $root - local.set $root|20 - local.get $fl - local.set $fl|21 - local.get $sl - local.set $sl|22 - local.get $block - local.set $head|23 - local.get $root|20 - local.get $fl|21 - i32.const 4 - i32.shl - local.get $sl|22 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head|23 - i32.store offset=96 - local.get $root - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 1 - local.get $fl - i32.shl - i32.or - call $~lib/rt/tlsf/Root#set:flMap - local.get $root - local.set $root|26 - local.get $fl - local.set $fl|27 - block $~lib/rt/tlsf/GETSL|inlined.1 (result i32) - local.get $root - local.set $root|24 - local.get $fl - local.set $fl|25 - local.get $root|24 - local.get $fl|25 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.1 - end - i32.const 1 - local.get $sl - i32.shl - i32.or - local.set $slMap - local.get $root|26 - local.get $fl|27 - i32.const 2 - i32.shl - i32.add - local.get $slMap - i32.store offset=4 - ) - (func $~lib/rt/tlsf/addMemory (param $root i32) (param $start i32) (param $endU64 i64) (result i32) - (local $end i32) - (local $root|4 i32) - (local $tail i32) - (local $tailInfo i32) - (local $size i32) - (local $leftSize i32) - (local $left i32) - (local $root|10 i32) - (local $tail|11 i32) - local.get $endU64 - i32.wrap_i64 - local.set $end - i32.const 1 - drop - local.get $start - i64.extend_i32_u - local.get $endU64 - i64.le_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 382 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $start - i32.const 4 - i32.add - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - i32.const 4 - i32.sub - local.set $start - local.get $end - i32.const 15 - i32.const -1 - i32.xor - i32.and - local.set $end - block $~lib/rt/tlsf/GETTAIL|inlined.0 (result i32) - local.get $root - local.set $root|4 - local.get $root|4 - i32.load offset=1568 - br $~lib/rt/tlsf/GETTAIL|inlined.0 - end - local.set $tail - i32.const 0 - local.set $tailInfo - local.get $tail - if - i32.const 1 - drop - local.get $start - local.get $tail - i32.const 4 - i32.add - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 389 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $start - i32.const 16 - i32.sub - local.get $tail - i32.eq - if - local.get $start - i32.const 16 - i32.sub - local.set $start - local.get $tail - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $tailInfo - else - end - else - i32.const 1 - drop - local.get $start - local.get $root - i32.const 1572 - i32.add - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 402 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - end - local.get $end - local.get $start - i32.sub - local.set $size - local.get $size - i32.const 4 - i32.const 12 - i32.add - i32.const 4 - i32.add - i32.lt_u - if - i32.const 0 - return - end - local.get $size - i32.const 2 - i32.const 4 - i32.mul - i32.sub - local.set $leftSize - local.get $start - local.set $left - local.get $left - local.get $leftSize - i32.const 1 - i32.or - local.get $tailInfo - i32.const 2 - i32.and - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $left - i32.const 0 - call $~lib/rt/tlsf/Block#set:prev - local.get $left - i32.const 0 - call $~lib/rt/tlsf/Block#set:next - local.get $start - i32.const 4 - i32.add - local.get $leftSize - i32.add - local.set $tail - local.get $tail - i32.const 0 - i32.const 2 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.set $root|10 - local.get $tail - local.set $tail|11 - local.get $root|10 - local.get $tail|11 - i32.store offset=1568 - local.get $root - local.get $left - call $~lib/rt/tlsf/insertBlock - i32.const 1 - return - ) - (func $~lib/rt/tlsf/initialize - (local $rootOffset i32) - (local $pagesBefore i32) - (local $pagesNeeded i32) - (local $root i32) - (local $root|4 i32) - (local $tail i32) - (local $fl i32) - (local $root|7 i32) - (local $fl|8 i32) - (local $slMap i32) - (local $sl i32) - (local $root|11 i32) - (local $fl|12 i32) - (local $sl|13 i32) - (local $head i32) - (local $memStart i32) - i32.const 0 - drop - global.get $~lib/memory/__heap_base - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - local.set $rootOffset - memory.size - local.set $pagesBefore - local.get $rootOffset - i32.const 1572 - i32.add - i32.const 65535 - i32.add - i32.const 65535 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.shr_u - local.set $pagesNeeded - local.get $pagesNeeded - local.get $pagesBefore - i32.gt_s - if (result i32) - local.get $pagesNeeded - local.get $pagesBefore - i32.sub - memory.grow - i32.const 0 - i32.lt_s - else - i32.const 0 - end - if - unreachable - end - local.get $rootOffset - local.set $root - local.get $root - i32.const 0 - call $~lib/rt/tlsf/Root#set:flMap - local.get $root - local.set $root|4 - i32.const 0 - local.set $tail - local.get $root|4 - local.get $tail - i32.store offset=1568 - i32.const 0 - local.set $fl - loop $for-loop|0 - local.get $fl - i32.const 23 - i32.lt_u - if - local.get $root - local.set $root|7 - local.get $fl - local.set $fl|8 - i32.const 0 - local.set $slMap - local.get $root|7 - local.get $fl|8 - i32.const 2 - i32.shl - i32.add - local.get $slMap - i32.store offset=4 - i32.const 0 - local.set $sl - loop $for-loop|1 - local.get $sl - i32.const 16 - i32.lt_u - if - local.get $root - local.set $root|11 - local.get $fl - local.set $fl|12 - local.get $sl - local.set $sl|13 - i32.const 0 - local.set $head - local.get $root|11 - local.get $fl|12 - i32.const 4 - i32.shl - local.get $sl|13 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head - i32.store offset=96 - local.get $sl - i32.const 1 - i32.add - local.set $sl - br $for-loop|1 - end - end - local.get $fl - i32.const 1 - i32.add - local.set $fl - br $for-loop|0 - end - end - local.get $rootOffset - i32.const 1572 - i32.add - local.set $memStart - i32.const 0 - drop - local.get $root - local.get $memStart - memory.size - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - drop - local.get $root - global.set $~lib/rt/tlsf/ROOT - ) - (func $~lib/rt/tlsf/checkUsedBlock (param $ptr i32) (result i32) - (local $block i32) - local.get $ptr - i32.const 4 - i32.sub - local.set $block - local.get $ptr - i32.const 0 - i32.ne - if (result i32) - local.get $ptr - i32.const 15 - i32.and - i32.eqz - else - i32.const 0 - end - if (result i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 1 - i32.and - i32.eqz - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 562 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - local.get $block - return - ) - (func $~lib/rt/tlsf/freeBlock (param $root i32) (param $block i32) - i32.const 0 - drop - local.get $block - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 1 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.get $block - call $~lib/rt/tlsf/insertBlock - ) - (func $~lib/rt/tlsf/__free (param $ptr i32) - local.get $ptr - global.get $~lib/memory/__heap_base - i32.lt_u - if - return - end - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $ptr - call $~lib/rt/tlsf/checkUsedBlock - call $~lib/rt/tlsf/freeBlock - ) - (func $~lib/rt/itcms/free (param $obj i32) - local.get $obj - global.get $~lib/memory/__heap_base - i32.lt_u - if - local.get $obj - i32.const 0 - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $obj - i32.const 0 - call $~lib/rt/itcms/Object#set:prev - else - global.get $~lib/rt/itcms/total - local.get $obj - call $~lib/rt/itcms/Object#get:size - i32.sub - global.set $~lib/rt/itcms/total - i32.const 0 - drop - local.get $obj - i32.const 4 - i32.add - call $~lib/rt/tlsf/__free - end - ) - (func $~lib/rt/itcms/step (result i32) - (local $obj i32) - (local $1 i32) - (local $black i32) - (local $from i32) - block $break|0 - block $case2|0 - block $case1|0 - block $case0|0 - global.get $~lib/rt/itcms/state - local.set $1 - local.get $1 - i32.const 0 - i32.eq - br_if $case0|0 - local.get $1 - i32.const 1 - i32.eq - br_if $case1|0 - local.get $1 - i32.const 2 - i32.eq - br_if $case2|0 - br $break|0 - end - i32.const 1 - global.set $~lib/rt/itcms/state - i32.const 0 - global.set $~lib/rt/itcms/visitCount - i32.const 0 - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/iter - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - global.get $~lib/rt/itcms/white - i32.eqz - local.set $black - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - loop $while-continue|1 - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - global.set $~lib/rt/itcms/iter - local.get $obj - call $~lib/rt/itcms/Object#get:color - local.get $black - i32.ne - if - local.get $obj - local.get $black - call $~lib/rt/itcms/Object#set:color - i32.const 0 - global.set $~lib/rt/itcms/visitCount - local.get $obj - i32.const 20 - i32.add - i32.const 0 - call $~lib/rt/__visit_members - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - local.get $obj - call $~lib/rt/itcms/Object#get:next - local.set $obj - br $while-continue|1 - end - end - i32.const 0 - global.set $~lib/rt/itcms/visitCount - i32.const 0 - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.eq - if - i32.const 0 - call $~lib/rt/itcms/visitStack - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - loop $while-continue|2 - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - call $~lib/rt/itcms/Object#get:color - local.get $black - i32.ne - if - local.get $obj - local.get $black - call $~lib/rt/itcms/Object#set:color - local.get $obj - i32.const 20 - i32.add - i32.const 0 - call $~lib/rt/__visit_members - end - local.get $obj - call $~lib/rt/itcms/Object#get:next - local.set $obj - br $while-continue|2 - end - end - global.get $~lib/rt/itcms/fromSpace - local.set $from - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/fromSpace - local.get $from - global.set $~lib/rt/itcms/toSpace - local.get $black - global.set $~lib/rt/itcms/white - local.get $from - call $~lib/rt/itcms/Object#get:next - global.set $~lib/rt/itcms/iter - i32.const 2 - global.set $~lib/rt/itcms/state - end - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - global.get $~lib/rt/itcms/iter - local.set $obj - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - call $~lib/rt/itcms/Object#get:next - global.set $~lib/rt/itcms/iter - i32.const 1 - drop - local.get $obj - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eqz - i32.eq - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 229 - i32.const 20 - call $~lib/builtins/abort - unreachable - end - local.get $obj - call $~lib/rt/itcms/free - i32.const 10 - return - end - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - call $~lib/rt/itcms/Object#set:nextWithColor - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - call $~lib/rt/itcms/Object#set:prev - i32.const 0 - global.set $~lib/rt/itcms/state - br $break|0 - end - i32.const 0 - return - ) - (func $~lib/rt/itcms/interrupt - (local $budget i32) - i32.const 0 - drop - i32.const 0 - drop - i32.const 1024 - i32.const 200 - i32.mul - i32.const 100 - i32.div_u - local.set $budget - loop $do-loop|0 - local.get $budget - call $~lib/rt/itcms/step - i32.sub - local.set $budget - global.get $~lib/rt/itcms/state - i32.const 0 - i32.eq - if - i32.const 0 - drop - global.get $~lib/rt/itcms/total - i64.extend_i32_u - i32.const 200 - i64.extend_i32_u - i64.mul - i64.const 100 - i64.div_u - i32.wrap_i64 - i32.const 1024 - i32.add - global.set $~lib/rt/itcms/threshold - i32.const 0 - drop - return - end - local.get $budget - i32.const 0 - i32.gt_s - br_if $do-loop|0 - end - i32.const 0 - drop - global.get $~lib/rt/itcms/total - i32.const 1024 - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.sub - i32.const 1024 - i32.lt_u - i32.mul - i32.add - global.set $~lib/rt/itcms/threshold - i32.const 0 - drop - ) - (func $~lib/rt/tlsf/computeSize (param $size i32) (result i32) - local.get $size - i32.const 12 - i32.le_u - if (result i32) - i32.const 12 - else - local.get $size - i32.const 4 - i32.add - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - i32.const 4 - i32.sub - end - return - ) - (func $~lib/rt/tlsf/prepareSize (param $size i32) (result i32) - local.get $size - i32.const 1073741820 - i32.gt_u - if - i32.const 288 - i32.const 624 - i32.const 461 - i32.const 29 - call $~lib/builtins/abort - unreachable - end - local.get $size - call $~lib/rt/tlsf/computeSize - return - ) - (func $~lib/rt/tlsf/roundSize (param $size i32) (result i32) - local.get $size - i32.const 536870910 - i32.lt_u - if (result i32) - local.get $size - i32.const 1 - i32.const 27 - local.get $size - i32.clz - i32.sub - i32.shl - i32.add - i32.const 1 - i32.sub - else - local.get $size - end - return - ) - (func $~lib/rt/tlsf/searchBlock (param $root i32) (param $size i32) (result i32) - (local $fl i32) - (local $sl i32) - (local $requestSize i32) - (local $root|5 i32) - (local $fl|6 i32) - (local $slMap i32) - (local $head i32) - (local $flMap i32) - (local $root|10 i32) - (local $fl|11 i32) - (local $root|12 i32) - (local $fl|13 i32) - (local $sl|14 i32) - (local $root|15 i32) - (local $fl|16 i32) - (local $sl|17 i32) - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - call $~lib/rt/tlsf/roundSize - local.set $requestSize - i32.const 4 - i32.const 8 - i32.mul - i32.const 1 - i32.sub - local.get $requestSize - i32.clz - i32.sub - local.set $fl - local.get $requestSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 334 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETSL|inlined.2 (result i32) - local.get $root - local.set $root|5 - local.get $fl - local.set $fl|6 - local.get $root|5 - local.get $fl|6 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.2 - end - i32.const 0 - i32.const -1 - i32.xor - local.get $sl - i32.shl - i32.and - local.set $slMap - i32.const 0 - local.set $head - local.get $slMap - i32.eqz - if - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 0 - i32.const -1 - i32.xor - local.get $fl - i32.const 1 - i32.add - i32.shl - i32.and - local.set $flMap - local.get $flMap - i32.eqz - if - i32.const 0 - local.set $head - else - local.get $flMap - i32.ctz - local.set $fl - block $~lib/rt/tlsf/GETSL|inlined.3 (result i32) - local.get $root - local.set $root|10 - local.get $fl - local.set $fl|11 - local.get $root|10 - local.get $fl|11 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.3 - end - local.set $slMap - i32.const 1 - drop - local.get $slMap - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 347 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETHEAD|inlined.2 (result i32) - local.get $root - local.set $root|12 - local.get $fl - local.set $fl|13 - local.get $slMap - i32.ctz - local.set $sl|14 - local.get $root|12 - local.get $fl|13 - i32.const 4 - i32.shl - local.get $sl|14 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.2 - end - local.set $head - end - else - block $~lib/rt/tlsf/GETHEAD|inlined.3 (result i32) - local.get $root - local.set $root|15 - local.get $fl - local.set $fl|16 - local.get $slMap - i32.ctz - local.set $sl|17 - local.get $root|15 - local.get $fl|16 - i32.const 4 - i32.shl - local.get $sl|17 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.3 - end - local.set $head - end - local.get $head - return - ) - (func $~lib/rt/tlsf/growMemory (param $root i32) (param $size i32) - (local $pagesBefore i32) - (local $root|3 i32) - (local $pagesNeeded i32) - (local $5 i32) - (local $6 i32) - (local $pagesWanted i32) - (local $pagesAfter i32) - i32.const 0 - drop - local.get $size - i32.const 256 - i32.ge_u - if - local.get $size - call $~lib/rt/tlsf/roundSize - local.set $size - end - memory.size - local.set $pagesBefore - local.get $size - i32.const 4 - local.get $pagesBefore - i32.const 16 - i32.shl - i32.const 4 - i32.sub - block $~lib/rt/tlsf/GETTAIL|inlined.1 (result i32) - local.get $root - local.set $root|3 - local.get $root|3 - i32.load offset=1568 - br $~lib/rt/tlsf/GETTAIL|inlined.1 - end - i32.ne - i32.shl - i32.add - local.set $size - local.get $size - i32.const 65535 - i32.add - i32.const 65535 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.shr_u - local.set $pagesNeeded - local.get $pagesBefore - local.tee $5 - local.get $pagesNeeded - local.tee $6 - local.get $5 - local.get $6 - i32.gt_s - select - local.set $pagesWanted - local.get $pagesWanted - memory.grow - i32.const 0 - i32.lt_s - if - local.get $pagesNeeded - memory.grow - i32.const 0 - i32.lt_s - if - unreachable - end - end - memory.size - local.set $pagesAfter - local.get $root - local.get $pagesBefore - i32.const 16 - i32.shl - local.get $pagesAfter - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - drop - ) - (func $~lib/rt/tlsf/prepareBlock (param $root i32) (param $block i32) (param $size i32) - (local $blockInfo i32) - (local $remaining i32) - (local $spare i32) - (local $block|6 i32) - (local $block|7 i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $size - i32.const 4 - i32.add - i32.const 15 - i32.and - i32.eqz - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 361 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $size - i32.sub - local.set $remaining - local.get $remaining - i32.const 4 - i32.const 12 - i32.add - i32.ge_u - if - local.get $block - local.get $size - local.get $blockInfo - i32.const 2 - i32.and - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $block - i32.const 4 - i32.add - local.get $size - i32.add - local.set $spare - local.get $spare - local.get $remaining - i32.const 4 - i32.sub - i32.const 1 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.get $spare - call $~lib/rt/tlsf/insertBlock - else - local.get $block - local.get $blockInfo - i32.const 1 - i32.const -1 - i32.xor - i32.and - call $~lib/rt/common/BLOCK#set:mmInfo - block $~lib/rt/tlsf/GETRIGHT|inlined.3 (result i32) - local.get $block - local.set $block|7 - local.get $block|7 - i32.const 4 - i32.add - local.get $block|7 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.3 - end - block $~lib/rt/tlsf/GETRIGHT|inlined.2 (result i32) - local.get $block - local.set $block|6 - local.get $block|6 - i32.const 4 - i32.add - local.get $block|6 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.2 - end - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 2 - i32.const -1 - i32.xor - i32.and - call $~lib/rt/common/BLOCK#set:mmInfo - end - ) - (func $~lib/rt/tlsf/allocateBlock (param $root i32) (param $size i32) (result i32) - (local $payloadSize i32) - (local $block i32) - local.get $size - call $~lib/rt/tlsf/prepareSize - local.set $payloadSize - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/searchBlock - local.set $block - local.get $block - i32.eqz - if - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/growMemory - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/searchBlock - local.set $block - i32.const 1 - drop - local.get $block - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 499 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - end - i32.const 1 - drop - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $payloadSize - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 501 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $root - local.get $block - call $~lib/rt/tlsf/removeBlock - local.get $root - local.get $block - local.get $payloadSize - call $~lib/rt/tlsf/prepareBlock - i32.const 0 - drop - local.get $block - return - ) - (func $~lib/rt/tlsf/__alloc (param $size i32) (result i32) - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $size - call $~lib/rt/tlsf/allocateBlock - i32.const 4 - i32.add - return - ) - (func $~lib/rt/itcms/Object#set:rtId (param $this i32) (param $rtId i32) - local.get $this - local.get $rtId - i32.store offset=12 - ) - (func $~lib/rt/itcms/Object#set:rtSize (param $this i32) (param $rtSize i32) - local.get $this - local.get $rtSize - i32.store offset=16 - ) - (func $~lib/rt/itcms/__new (param $size i32) (param $id i32) (result i32) - (local $obj i32) - (local $ptr i32) - local.get $size - i32.const 1073741804 - i32.ge_u - if - i32.const 288 - i32.const 352 - i32.const 261 - i32.const 31 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.ge_u - if - call $~lib/rt/itcms/interrupt - end - i32.const 16 - local.get $size - i32.add - call $~lib/rt/tlsf/__alloc - i32.const 4 - i32.sub - local.set $obj - local.get $obj - local.get $id - call $~lib/rt/itcms/Object#set:rtId - local.get $obj - local.get $size - call $~lib/rt/itcms/Object#set:rtSize - local.get $obj - global.get $~lib/rt/itcms/fromSpace - global.get $~lib/rt/itcms/white - call $~lib/rt/itcms/Object#linkTo - global.get $~lib/rt/itcms/total - local.get $obj - call $~lib/rt/itcms/Object#get:size - i32.add - global.set $~lib/rt/itcms/total - local.get $obj - i32.const 20 - i32.add - local.set $ptr - local.get $ptr - i32.const 0 - local.get $size - memory.fill - local.get $ptr - return - ) - (func $assembly/arguments/Args#set:a (param $this i32) (param $a i32) - local.get $this - local.get $a - i32.store - ) - (func $assembly/arguments/Args#set:b (param $this i32) (param $b i32) - local.get $this - local.get $b - i32.store offset=4 - ) - (func $assembly/arguments/Args#set:c (param $this i32) (param $c i32) - local.get $this - local.get $c - i32.store offset=8 - ) - (func $assembly/arguments/Args#set:d (param $this i32) (param $d i32) - local.get $this - local.get $d - i32.store offset=12 - ) - (func $start:assembly/arguments~anonymous|0 (param $_d i32) (param $_l i32) (result i32) - i32.const 0 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - return - ) - (func $~lib/arraybuffer/ArrayBufferView#get:byteLength (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/arraybuffer/ArrayBufferView#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/itcms/__link (param $parentPtr i32) (param $childPtr i32) (param $expectMultiple i32) - (local $child i32) - (local $parent i32) - (local $parentColor i32) - local.get $childPtr - i32.eqz - if - return - end - i32.const 1 - drop - local.get $parentPtr - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 295 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $childPtr - i32.const 20 - i32.sub - local.set $child - local.get $child - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eq - if - local.get $parentPtr - i32.const 20 - i32.sub - local.set $parent - local.get $parent - call $~lib/rt/itcms/Object#get:color - local.set $parentColor - local.get $parentColor - global.get $~lib/rt/itcms/white - i32.eqz - i32.eq - if - local.get $expectMultiple - if - local.get $parent - call $~lib/rt/itcms/Object#makeGray - else - local.get $child - call $~lib/rt/itcms/Object#makeGray - end - else - local.get $parentColor - i32.const 3 - i32.eq - if (result i32) - global.get $~lib/rt/itcms/state - i32.const 1 - i32.eq - else - i32.const 0 - end - if - local.get $child - call $~lib/rt/itcms/Object#makeGray - end - end - end - ) - (func $~lib/arraybuffer/ArrayBufferView#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/arguments/Nibbles#set:low (param $this i32) (param $low i32) - local.get $this - local.get $low - i32.store8 - ) - (func $assembly/arguments/Nibbles#set:hig (param $this i32) (param $hig i32) - local.get $this - local.get $hig - i32.store8 offset=1 - ) - (func $assembly/arguments/Nibbles#get:low (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $assembly/arguments/Nibbles#get:hig (param $this i32) (result i32) - local.get $this - i32.load8_u offset=1 - ) - (func $assembly/arguments/Args#get:a (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/arguments/Args#get:b (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $start:assembly/arguments - (local $0 i32) - (local $1 i32) - (local $2 i32) - memory.size - i32.const 16 - i32.shl - global.get $~lib/memory/__heap_base - i32.sub - i32.const 1 - i32.shr_u - global.set $~lib/rt/itcms/threshold - i32.const 400 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/pinSpace - i32.const 432 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/toSpace - i32.const 576 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/fromSpace - ) - (func $~lib/math/ipow32 (param $x i32) (param $e i32) (result i32) - (local $out i32) - (local $log i32) - (local $4 i32) - i32.const 1 - local.set $out - i32.const 0 - i32.const 1 - i32.lt_s - drop - local.get $x - i32.const 2 - i32.eq - if - i32.const 1 - local.get $e - i32.shl - i32.const 0 - local.get $e - i32.const 32 - i32.lt_u - select - return - end - local.get $e - i32.const 0 - i32.le_s - if - local.get $x - i32.const -1 - i32.eq - if - i32.const -1 - i32.const 1 - local.get $e - i32.const 1 - i32.and - select - return - end - local.get $e - i32.const 0 - i32.eq - local.get $x - i32.const 1 - i32.eq - i32.or - return - else - local.get $e - i32.const 1 - i32.eq - if - local.get $x - return - else - local.get $e - i32.const 2 - i32.eq - if - local.get $x - local.get $x - i32.mul - return - else - local.get $e - i32.const 32 - i32.lt_s - if - i32.const 32 - local.get $e - i32.clz - i32.sub - local.set $log - block $break|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $log - local.set $4 - local.get $4 - i32.const 5 - i32.eq - br_if $case0|0 - local.get $4 - i32.const 4 - i32.eq - br_if $case1|0 - local.get $4 - i32.const 3 - i32.eq - br_if $case2|0 - local.get $4 - i32.const 2 - i32.eq - br_if $case3|0 - local.get $4 - i32.const 1 - i32.eq - br_if $case4|0 - br $break|0 - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - end - local.get $out - return - end - end - end - end - loop $while-continue|1 - local.get $e - if - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - br $while-continue|1 - end - end - local.get $out - return - ) - (func $start:assembly/memory-page - i32.const 2 - i32.const 16 - call $~lib/math/ipow32 - global.set $assembly/memory-page/SEGMENT_SIZE - global.get $assembly/memory-page/SEGMENT_SIZE - global.set $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/PAGE_SIZE - i32.div_u - global.set $assembly/memory-page/RESERVED_PAGES - i32.const 2 - i32.const 29 - call $~lib/math/ipow32 - global.set $assembly/memory-page/ALLOCATE_EAGERLY - ) - (func $assembly/memory/MaybePageFault#set:isFault (param $this i32) (param $isFault i32) - local.get $this - local.get $isFault - i32.store8 - ) - (func $assembly/memory/MaybePageFault#set:isAccess (param $this i32) (param $isAccess i32) - local.get $this - local.get $isAccess - i32.store8 offset=1 - ) - (func $assembly/memory/MaybePageFault#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store offset=4 - ) - (func $~lib/arraybuffer/ArrayBufferView#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/arraybuffer/ArrayBufferView#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/arraybuffer/ArrayBufferView#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $assembly/memory-page/Page#set:access (param $this i32) (param $access i32) - local.get $this - local.get $access - i32.store - ) - (func $assembly/memory-page/Page#set:raw (param $this i32) (param $raw i32) - local.get $this - local.get $raw - i32.store offset=4 - local.get $this - local.get $raw - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/RawPage#set:id (param $this i32) (param $id i32) - local.get $this - local.get $id - i32.store - ) - (func $assembly/memory-page/RawPage#set:page (param $this i32) (param $page i32) - local.get $this - local.get $page - i32.store offset=4 - local.get $this - local.get $page - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/instructions/utils/reg (param $v i64) (result i32) - local.get $v - global.get $assembly/registers/NO_OF_REGISTERS - i64.extend_i32_s - i64.ge_u - if (result i32) - global.get $assembly/registers/NO_OF_REGISTERS - i32.const 1 - i32.sub - else - local.get $v - i32.wrap_i64 - end - return - ) - (func $~lib/rt/common/OBJECT#get:rtSize (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 3 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i64) - local.get $this - local.get $index - i32.const 3 - i32.shl - i32.add - local.get $value - i64.store - i32.const 0 - drop - ) - (func $assembly/instructions/outcome/OutcomeData#set:outcome (param $this i32) (param $outcome i32) - local.get $this - local.get $outcome - i32.store - ) - (func $assembly/instructions/outcome/OutcomeData#set:staticJump (param $this i32) (param $staticJump i32) - local.get $this - local.get $staticJump - i32.store offset=4 - ) - (func $assembly/instructions/outcome/OutcomeData#set:dJump (param $this i32) (param $dJump i32) - local.get $this - local.get $dJump - i32.store offset=8 - ) - (func $assembly/instructions/outcome/OutcomeData#set:result (param $this i32) (param $result i32) - local.get $this - local.get $result - i32.store offset=12 - ) - (func $assembly/instructions/outcome/OutcomeData#set:exitCode (param $this i32) (param $exitCode i32) - local.get $this - local.get $exitCode - i32.store offset=16 - ) - (func $assembly/instructions/outcome/ok (result i32) - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - return - ) - (func $assembly/instructions/utils/u8SignExtend (param $v i32) (result i64) - local.get $v - i32.extend8_s - i64.extend_i32_s - return - ) - (func $assembly/instructions/utils/u16SignExtend (param $v i32) (result i64) - local.get $v - i32.extend16_s - i64.extend_i32_s - return - ) - (func $~lib/polyfills/bswap (param $value i64) (result i64) - (local $a i64) - (local $b i64) - (local $v i64) - i32.const 1 - drop - i32.const 8 - i32.const 1 - i32.eq - drop - i32.const 8 - i32.const 2 - i32.eq - drop - i32.const 8 - i32.const 4 - i32.eq - drop - i32.const 8 - i32.const 8 - i32.eq - drop - local.get $value - i64.const 8 - i64.shr_u - i64.const 71777214294589695 - i64.and - local.set $a - local.get $value - i64.const 71777214294589695 - i64.and - i64.const 8 - i64.shl - local.set $b - local.get $a - local.get $b - i64.or - local.set $v - local.get $v - i64.const 16 - i64.shr_u - i64.const 281470681808895 - i64.and - local.set $a - local.get $v - i64.const 281470681808895 - i64.and - i64.const 16 - i64.shl - local.set $b - local.get $a - local.get $b - i64.or - i64.const 32 - i64.rotr - return - ) - (func $assembly/registers/newRegisters (result i32) - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - return - ) - (func $"~lib/map/Map#set:buckets" (param $this i32) (param $buckets i32) - local.get $this - local.get $buckets - i32.store - local.get $this - local.get $buckets - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $"~lib/map/Map#set:bucketsMask" (param $this i32) (param $bucketsMask i32) - local.get $this - local.get $bucketsMask - i32.store offset=4 - ) - (func $"~lib/map/Map#set:entries" (param $this i32) (param $entries i32) - local.get $this - local.get $entries - i32.store offset=8 - local.get $this - local.get $entries - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $"~lib/map/Map#set:entriesCapacity" (param $this i32) (param $entriesCapacity i32) - local.get $this - local.get $entriesCapacity - i32.store offset=12 - ) - (func $"~lib/map/Map#set:entriesOffset" (param $this i32) (param $entriesOffset i32) - local.get $this - local.get $entriesOffset - i32.store offset=16 - ) - (func $"~lib/map/Map#set:entriesCount" (param $this i32) (param $entriesCount i32) - local.get $this - local.get $entriesCount - i32.store offset=20 - ) - (func $assembly/memory/MemoryBuilder#set:pages (param $this i32) (param $pages i32) - local.get $this - local.get $pages - i32.store - local.get $this - local.get $pages - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/Arena#set:arenaBytes (param $this i32) (param $arenaBytes i32) - local.get $this - local.get $arenaBytes - i32.store offset=4 - ) - (func $~lib/rt/__newBuffer (param $size i32) (param $id i32) (param $data i32) (result i32) - (local $buffer i32) - local.get $size - local.get $id - call $~lib/rt/itcms/__new - local.set $buffer - local.get $data - if - local.get $buffer - local.get $data - local.get $size - memory.copy - end - local.get $buffer - return - ) - (func $assembly/memory-page/Arena#set:free (param $this i32) (param $free i32) - local.get $this - local.get $free - i32.store - local.get $this - local.get $free - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/Arena#set:extraPageIndex (param $this i32) (param $extraPageIndex i32) - local.get $this - local.get $extraPageIndex - i32.store offset=8 - ) - (func $assembly/memory-page/Arena#get:arenaBytes (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Arena#get:free (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/arraybuffer/ArrayBuffer#get:byteLength (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - return - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/rt/itcms/Object#get:rtSize (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $~lib/rt/itcms/__renew (param $oldPtr i32) (param $size i32) (result i32) - (local $oldObj i32) - (local $newPtr i32) - (local $4 i32) - (local $5 i32) - local.get $oldPtr - i32.const 20 - i32.sub - local.set $oldObj - local.get $size - local.get $oldObj - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.sub - i32.le_u - if - local.get $oldObj - local.get $size - call $~lib/rt/itcms/Object#set:rtSize - local.get $oldPtr - return - end - local.get $size - local.get $oldObj - call $~lib/rt/itcms/Object#get:rtId - call $~lib/rt/itcms/__new - local.set $newPtr - local.get $newPtr - local.get $oldPtr - local.get $size - local.tee $4 - local.get $oldObj - call $~lib/rt/itcms/Object#get:rtSize - local.tee $5 - local.get $4 - local.get $5 - i32.lt_u - select - memory.copy - local.get $newPtr - return - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $assembly/memory/MemoryBuilder#set:arena (param $this i32) (param $arena i32) - local.get $this - local.get $arena - i32.store offset=4 - local.get $this - local.get $arena - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/util/hash/HASH (param $key i32) (result i32) - (local $key|1 i32) - (local $len i32) - (local $h i32) - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 4 - i32.const 4 - i32.le_u - drop - block $~lib/util/hash/hash32|inlined.0 (result i32) - local.get $key - local.set $key|1 - i32.const 4 - local.set $len - i32.const 0 - i32.const 374761393 - i32.add - local.get $len - i32.add - local.set $h - local.get $h - local.get $key|1 - i32.const -1028477379 - i32.mul - i32.add - local.set $h - local.get $h - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 15 - i32.shr_u - i32.xor - local.set $h - local.get $h - i32.const -2048144777 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 13 - i32.shr_u - i32.xor - local.set $h - local.get $h - i32.const -1028477379 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 16 - i32.shr_u - i32.xor - local.set $h - local.get $h - br $~lib/util/hash/hash32|inlined.0 - end - return - ) - (func $"~lib/map/Map#get:buckets" (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $"~lib/map/Map#get:bucketsMask" (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $"~lib/map/MapEntry#get:taggedNext" (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#get:key" (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/Memory#set:lastAllocatedPage (param $this i32) (param $lastAllocatedPage i32) - local.get $this - local.get $lastAllocatedPage - i32.store - ) - (func $assembly/memory/Memory#set:arena (param $this i32) (param $arena i32) - local.get $this - local.get $arena - i32.store offset=4 - local.get $this - local.get $arena - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#set:pages (param $this i32) (param $pages i32) - local.get $this - local.get $pages - i32.store offset=8 - local.get $this - local.get $pages - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#set:sbrkAddress (param $this i32) (param $sbrkAddress i32) - local.get $this - local.get $sbrkAddress - i32.store offset=12 - ) - (func $assembly/memory/MemoryBuilder#get:arena (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/MemoryBuilder#get:pages (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/test/Assert#set:isOkay (param $this i32) (param $isOkay i32) - local.get $this - local.get $isOkay - i32.store8 - ) - (func $assembly/test/Assert#set:errors (param $this i32) (param $errors i32) - local.get $this - local.get $errors - i32.store offset=4 - local.get $this - local.get $errors - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/instructions/outcome/OutcomeData#get:outcome (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/util/number/decimalCount32 (param $value i32) (result i32) - local.get $value - i32.const 100000 - i32.lt_u - if - local.get $value - i32.const 100 - i32.lt_u - if - i32.const 1 - local.get $value - i32.const 10 - i32.ge_u - i32.add - return - else - i32.const 3 - local.get $value - i32.const 10000 - i32.ge_u - i32.add - local.get $value - i32.const 1000 - i32.ge_u - i32.add - return - end - unreachable - else - local.get $value - i32.const 10000000 - i32.lt_u - if - i32.const 6 - local.get $value - i32.const 1000000 - i32.ge_u - i32.add - return - else - i32.const 8 - local.get $value - i32.const 1000000000 - i32.ge_u - i32.add - local.get $value - i32.const 100000000 - i32.ge_u - i32.add - return - end - unreachable - end - unreachable - ) - (func $~lib/util/number/utoa32_dec_lut (param $buffer i32) (param $num i32) (param $offset i32) - (local $t i32) - (local $r i32) - (local $d1 i32) - (local $d2 i32) - (local $digits1 i64) - (local $digits2 i64) - (local $t|9 i32) - (local $d1|10 i32) - (local $digits i32) - (local $digits|12 i32) - (local $digit i32) - loop $while-continue|0 - local.get $num - i32.const 10000 - i32.ge_u - if - local.get $num - i32.const 10000 - i32.div_u - local.set $t - local.get $num - i32.const 10000 - i32.rem_u - local.set $r - local.get $t - local.set $num - local.get $r - i32.const 100 - i32.div_u - local.set $d1 - local.get $r - i32.const 100 - i32.rem_u - local.set $d2 - i32.const 2508 - local.get $d1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 2508 - local.get $d2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $num - i32.const 100 - i32.ge_u - if - local.get $num - i32.const 100 - i32.div_u - local.set $t|9 - local.get $num - i32.const 100 - i32.rem_u - local.set $d1|10 - local.get $t|9 - local.set $num - local.get $offset - i32.const 2 - i32.sub - local.set $offset - i32.const 2508 - local.get $d1|10 - i32.const 2 - i32.shl - i32.add - i32.load - local.set $digits - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits - i32.store - end - local.get $num - i32.const 10 - i32.ge_u - if - local.get $offset - i32.const 2 - i32.sub - local.set $offset - i32.const 2508 - local.get $num - i32.const 2 - i32.shl - i32.add - i32.load - local.set $digits|12 - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits|12 - i32.store - else - local.get $offset - i32.const 1 - i32.sub - local.set $offset - i32.const 48 - local.get $num - i32.add - local.set $digit - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digit - i32.store16 - end - ) - (func $~lib/util/number/utoa_hex_lut (param $buffer i32) (param $num i64) (param $offset i32) - loop $while-continue|0 - local.get $offset - i32.const 2 - i32.ge_u - if - local.get $offset - i32.const 2 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 2928 - local.get $num - i32.wrap_i64 - i32.const 255 - i32.and - i32.const 2 - i32.shl - i32.add - i32.load - i32.store - local.get $num - i64.const 8 - i64.shr_u - local.set $num - br $while-continue|0 - end - end - local.get $offset - i32.const 1 - i32.and - if - local.get $buffer - i32.const 2928 - local.get $num - i32.wrap_i64 - i32.const 6 - i32.shl - i32.add - i32.load16_u - i32.store16 - end - ) - (func $~lib/util/number/ulog_base (param $num i64) (param $base i32) (result i32) - (local $value i32) - (local $b64 i64) - (local $b i64) - (local $e i32) - block $~lib/util/number/isPowerOf2|inlined.0 (result i32) - local.get $base - local.set $value - local.get $value - i32.popcnt - i32.const 1 - i32.eq - br $~lib/util/number/isPowerOf2|inlined.0 - end - if - i32.const 63 - local.get $num - i64.clz - i32.wrap_i64 - i32.sub - i32.const 31 - local.get $base - i32.clz - i32.sub - i32.div_u - i32.const 1 - i32.add - return - end - local.get $base - i64.extend_i32_s - local.set $b64 - local.get $b64 - local.set $b - i32.const 1 - local.set $e - loop $while-continue|0 - local.get $num - local.get $b - i64.ge_u - if - local.get $num - local.get $b - i64.div_u - local.set $num - local.get $b - local.get $b - i64.mul - local.set $b - local.get $e - i32.const 1 - i32.shl - local.set $e - br $while-continue|0 - end - end - loop $while-continue|1 - local.get $num - i64.const 1 - i64.ge_u - if - local.get $num - local.get $b64 - i64.div_u - local.set $num - local.get $e - i32.const 1 - i32.add - local.set $e - br $while-continue|1 - end - end - local.get $e - i32.const 1 - i32.sub - return - ) - (func $~lib/util/number/utoa64_any_core (param $buffer i32) (param $num i64) (param $offset i32) (param $radix i32) - (local $base i64) - (local $shift i64) - (local $mask i64) - (local $q i64) - local.get $radix - i64.extend_i32_s - local.set $base - local.get $radix - local.get $radix - i32.const 1 - i32.sub - i32.and - i32.const 0 - i32.eq - if - local.get $radix - i32.ctz - i32.const 7 - i32.and - i64.extend_i32_s - local.set $shift - local.get $base - i64.const 1 - i64.sub - local.set $mask - loop $do-loop|0 - local.get $offset - i32.const 1 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 3984 - local.get $num - local.get $mask - i64.and - i32.wrap_i64 - i32.const 1 - i32.shl - i32.add - i32.load16_u - i32.store16 - local.get $num - local.get $shift - i64.shr_u - local.set $num - local.get $num - i64.const 0 - i64.ne - br_if $do-loop|0 - end - else - loop $do-loop|1 - local.get $offset - i32.const 1 - i32.sub - local.set $offset - local.get $num - local.get $base - i64.div_u - local.set $q - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 3984 - local.get $num - local.get $q - local.get $base - i64.mul - i64.sub - i32.wrap_i64 - i32.const 1 - i32.shl - i32.add - i32.load16_u - i32.store16 - local.get $q - local.set $num - local.get $num - i64.const 0 - i64.ne - br_if $do-loop|1 - end - end - ) - (func $~lib/number/I32#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/itoa32 - return - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/string/String#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 1 - i32.shr_u - return - ) - (func $assembly/test/Assert#get:errors (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array<~lib/string/String>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<~lib/string/String>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array<~lib/string/String>#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/util/number/decimalCount64High (param $value i64) (result i32) - local.get $value - i64.const 1000000000000000 - i64.lt_u - if - local.get $value - i64.const 1000000000000 - i64.lt_u - if - i32.const 10 - local.get $value - i64.const 100000000000 - i64.ge_u - i32.add - local.get $value - i64.const 10000000000 - i64.ge_u - i32.add - return - else - i32.const 13 - local.get $value - i64.const 100000000000000 - i64.ge_u - i32.add - local.get $value - i64.const 10000000000000 - i64.ge_u - i32.add - return - end - unreachable - else - local.get $value - i64.const 100000000000000000 - i64.lt_u - if - i32.const 16 - local.get $value - i64.const 10000000000000000 - i64.ge_u - i32.add - return - else - i32.const 18 - local.get $value - i64.const -8446744073709551616 - i64.ge_u - i32.add - local.get $value - i64.const 1000000000000000000 - i64.ge_u - i32.add - return - end - unreachable - end - unreachable - ) - (func $~lib/util/number/utoa64_dec_lut (param $buffer i32) (param $num i64) (param $offset i32) - (local $t i64) - (local $r i32) - (local $b i32) - (local $c i32) - (local $b1 i32) - (local $b2 i32) - (local $c1 i32) - (local $c2 i32) - (local $digits1 i64) - (local $digits2 i64) - loop $while-continue|0 - local.get $num - i64.const 100000000 - i64.ge_u - if - local.get $num - i64.const 100000000 - i64.div_u - local.set $t - local.get $num - local.get $t - i64.const 100000000 - i64.mul - i64.sub - i32.wrap_i64 - local.set $r - local.get $t - local.set $num - local.get $r - i32.const 10000 - i32.div_u - local.set $b - local.get $r - i32.const 10000 - i32.rem_u - local.set $c - local.get $b - i32.const 100 - i32.div_u - local.set $b1 - local.get $b - i32.const 100 - i32.rem_u - local.set $b2 - local.get $c - i32.const 100 - i32.div_u - local.set $c1 - local.get $c - i32.const 100 - i32.rem_u - local.set $c2 - i32.const 2508 - local.get $c1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 2508 - local.get $c2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - i32.const 2508 - local.get $b1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 2508 - local.get $b2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $buffer - local.get $num - i32.wrap_i64 - local.get $offset - call $~lib/util/number/utoa32_dec_lut - ) - (func $~lib/number/U64#toString (param $this i64) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/utoa64 - return - ) - (func $assembly/test/Test#set:name (param $this i32) (param $name i32) - local.get $this - local.get $name - i32.store - local.get $this - local.get $name - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/test/Test#set:ptr (param $this i32) (param $ptr i32) - local.get $this - local.get $ptr - i32.store offset=4 - local.get $this - local.get $ptr - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/number/I64#toString (param $this i64) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/itoa64 - return - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/utils/u32SignExtend (param $v i32) (result i64) - local.get $v - i64.extend_i32_s - return - ) - (func $assembly/arguments/Args#get:c (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/instructions/outcome/OutcomeData#get:staticJump (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/number/U32#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/utoa32 - return - ) - (func $~lib/math/ipow64 (param $x i64) (param $e i64) (result i64) - (local $out i64) - (local $log i32) - (local $4 i32) - i64.const 1 - local.set $out - i32.const 0 - i32.const 1 - i32.lt_s - drop - local.get $x - i64.const 2 - i64.eq - if - i64.const 1 - local.get $e - i64.shl - i64.const 0 - local.get $e - i64.const 64 - i64.lt_u - select - return - end - local.get $e - i64.const 0 - i64.le_s - if - local.get $x - i64.const -1 - i64.eq - if - i64.const -1 - i64.const 1 - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - select - return - end - local.get $e - i64.const 0 - i64.eq - i64.extend_i32_u - local.get $x - i64.const 1 - i64.eq - i64.extend_i32_u - i64.or - return - else - local.get $e - i64.const 1 - i64.eq - if - local.get $x - return - else - local.get $e - i64.const 2 - i64.eq - if - local.get $x - local.get $x - i64.mul - return - else - local.get $e - i64.const 64 - i64.lt_s - if - i32.const 64 - local.get $e - i64.clz - i32.wrap_i64 - i32.sub - local.set $log - block $break|0 - block $case5|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $log - local.set $4 - local.get $4 - i32.const 6 - i32.eq - br_if $case0|0 - local.get $4 - i32.const 5 - i32.eq - br_if $case1|0 - local.get $4 - i32.const 4 - i32.eq - br_if $case2|0 - local.get $4 - i32.const 3 - i32.eq - br_if $case3|0 - local.get $4 - i32.const 2 - i32.eq - br_if $case4|0 - local.get $4 - i32.const 1 - i32.eq - br_if $case5|0 - br $break|0 - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - end - local.get $out - return - end - end - end - end - loop $while-continue|1 - local.get $e - i64.const 0 - i64.ne - if - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - br $while-continue|1 - end - end - local.get $out - return - ) - (func $assembly/instructions/utils/mulUpperUnsigned (param $a i64) (param $b i64) (result i64) - (local $aHigh i64) - (local $aLow i64) - (local $bHigh i64) - (local $bLow i64) - (local $lowLow i64) - (local $lowHigh i64) - (local $highLow i64) - (local $highHigh i64) - (local $carry i64) - local.get $a - i64.const 32 - i64.shr_u - local.set $aHigh - local.get $a - i64.const 4294967295 - i64.and - local.set $aLow - local.get $b - i64.const 32 - i64.shr_u - local.set $bHigh - local.get $b - i64.const 4294967295 - i64.and - local.set $bLow - local.get $aLow - local.get $bLow - i64.mul - local.set $lowLow - local.get $aLow - local.get $bHigh - i64.mul - local.set $lowHigh - local.get $aHigh - local.get $bLow - i64.mul - local.set $highLow - local.get $aHigh - local.get $bHigh - i64.mul - local.set $highHigh - local.get $lowLow - i64.const 32 - i64.shr_u - local.get $lowHigh - i64.const 4294967295 - i64.and - i64.add - local.get $highLow - i64.const 4294967295 - i64.and - i64.add - local.set $carry - local.get $highHigh - local.get $lowHigh - i64.const 32 - i64.shr_u - i64.add - local.get $highLow - i64.const 32 - i64.shr_u - i64.add - local.get $carry - i64.const 32 - i64.shr_u - i64.add - return - ) - (func $assembly/instructions/utils/mulUpperSigned (param $a i64) (param $b i64) (result i64) - (local $isResultNegative i32) - (local $aAbs i64) - (local $bAbs i64) - (local $upper i64) - (local $lower i64) - i32.const 0 - local.set $isResultNegative - local.get $a - local.set $aAbs - local.get $b - local.set $bAbs - local.get $a - i64.const 0 - i64.lt_s - if - local.get $isResultNegative - i32.eqz - local.set $isResultNegative - local.get $a - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $aAbs - end - local.get $b - i64.const 0 - i64.lt_s - if - local.get $isResultNegative - i32.eqz - local.set $isResultNegative - local.get $b - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $bAbs - end - local.get $isResultNegative - if - local.get $aAbs - local.get $bAbs - call $assembly/instructions/utils/mulUpperUnsigned - local.set $upper - local.get $aAbs - local.get $bAbs - i64.mul - local.set $lower - local.get $upper - i64.const -1 - i64.xor - local.get $lower - i64.const 0 - i64.eq - if (result i64) - i64.const 1 - else - i64.const 0 - end - i64.add - return - end - local.get $aAbs - local.get $bAbs - call $assembly/instructions/utils/mulUpperUnsigned - return - ) - (func $assembly/instructions/utils/mulUpperSignedUnsigned (param $a i64) (param $b i64) (result i64) - (local $aAbs i64) - (local $upper i64) - (local $lower i64) - local.get $a - i64.const 0 - i64.lt_s - if - local.get $a - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $aAbs - local.get $aAbs - local.get $b - call $assembly/instructions/utils/mulUpperUnsigned - local.set $upper - local.get $aAbs - local.get $b - i64.mul - local.set $lower - local.get $upper - i64.const -1 - i64.xor - local.get $lower - i64.const 0 - i64.eq - if (result i64) - i64.const 1 - else - i64.const 0 - end - i64.add - return - end - local.get $a - local.get $b - call $assembly/instructions/utils/mulUpperUnsigned - return - ) - (func $assembly/instructions/rot/math.rot_r (param $v i64) (param $shift i64) (result i64) - local.get $v - local.get $shift - i64.rotr - return - ) - (func $assembly/instructions/rot/math.rot_r_32 (param $v i32) (param $shift i32) (result i32) - local.get $v - local.get $shift - i32.rotr - return - ) - (func $assembly/instructions/rot/math.rot_l (param $v i64) (param $shift i64) (result i64) - local.get $v - local.get $shift - i64.rotl - return - ) - (func $assembly/instructions/rot/math.rot_l_32 (param $v i32) (param $shift i32) (result i32) - local.get $v - local.get $shift - i32.rotl - return - ) - (func $assembly/memory/Chunks#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#set:first (param $this i32) (param $first i32) - local.get $this - local.get $first - i32.store offset=4 - local.get $this - local.get $first - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#set:second (param $this i32) (param $second i32) - local.get $this - local.get $second - i32.store offset=8 - local.get $this - local.get $second - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#get:pages (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/memory/PageData#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/PageData#set:page (param $this i32) (param $page i32) - local.get $this - local.get $page - i32.store offset=4 - local.get $this - local.get $page - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/PageData#set:relativeAddress (param $this i32) (param $relativeAddress i32) - local.get $this - local.get $relativeAddress - i32.store offset=8 - ) - (func $"~lib/map/MapEntry#get:value" (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Page#get:access (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/PageData#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/MaybePageFault#get:isFault (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $assembly/memory/PageData#get:page (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/PageData#get:relativeAddress (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/memory-page/Page#get:raw (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/RawPage#get:page (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i32) (param $start i32) (param $end i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $start - i32.add - local.tee $5 - i32.const 0 - local.tee $6 - local.get $5 - local.get $6 - i32.gt_u - select - else - local.get $start - local.tee $7 - local.get $len - local.tee $8 - local.get $7 - local.get $8 - i32.lt_s - select - end - local.set $start - local.get $end - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $end - i32.add - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_u - select - else - local.get $end - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - end - local.set $end - i32.const 1 - i32.const 1 - i32.eq - drop - local.get $start - local.get $end - i32.lt_s - if - local.get $ptr - local.get $start - i32.add - local.get $value - local.get $end - local.get $start - i32.sub - memory.fill - end - ) - (func $assembly/memory/Chunks#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/ChunkBytes#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/ChunkBytes#set:bytes (param $this i32) (param $bytes i32) - local.get $this - local.get $bytes - i32.store offset=4 - local.get $this - local.get $bytes - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#get:first (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/Chunks#get:second (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 0 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - i32.const 0 - drop - ) - (func $assembly/memory/Result#set:ok (param $this i32) (param $ok i64) - local.get $this - local.get $ok - i64.store - ) - (func $assembly/memory/Result#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store offset=8 - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/ChunkBytes#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/ChunkBytes#get:bytes (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/Result#get:ok (param $this i32) (result i64) - local.get $this - i64.load - ) - (func $assembly/memory/Result#get:fault (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/number/Bool#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - if (result i32) - i32.const 9040 - else - i32.const 9072 - end - return - ) - (func $assembly/memory/MaybePageFault#get:isAccess (param $this i32) (result i32) - local.get $this - i32.load8_u offset=1 - ) - (func $assembly/memory/MaybePageFault#get:fault (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Arena#get:extraPageIndex (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#set:value" (param $this i32) (param $value i32) - local.get $this - local.get $value - i32.store offset=4 - ) - (func $"~lib/map/Map#get:entriesOffset" (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $"~lib/map/Map#get:entriesCapacity" (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $"~lib/map/Map#get:entriesCount" (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $"~lib/map/Map#get:entries" (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#set:key" (param $this i32) (param $key i32) - local.get $this - local.get $key - i32.store - ) - (func $"~lib/map/MapEntry#set:taggedNext" (param $this i32) (param $taggedNext i32) - local.get $this - local.get $taggedNext - i32.store offset=8 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i32) (result i32) - (local $sign i32) - (local $dest i32) - (local $decimals i32) - (local $val32 i32) - (local $buffer|6 i32) - (local $num i32) - (local $offset i32) - i32.const 0 - local.set $sign - i32.const 0 - drop - local.get $buffer - local.get $sign - i32.const 1 - i32.shl - i32.add - local.set $dest - i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 0 - drop - local.get $value - i32.const 255 - i32.and - i32.const 10 - i32.lt_u - if - local.get $buffer - local.get $value - i32.const 255 - i32.and - i32.const 48 - i32.or - i32.store16 - i32.const 1 - return - end - i32.const 0 - local.set $decimals - i32.const 1 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 255 - i32.and - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - local.get $dest - local.set $buffer|6 - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|6 - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - local.get $sign - local.get $decimals - i32.add - return - ) - (func $~lib/util/string/compareImpl (param $str1 i32) (param $index1 i32) (param $str2 i32) (param $index2 i32) (param $len i32) (result i32) - (local $ptr1 i32) - (local $ptr2 i32) - (local $7 i32) - (local $a i32) - (local $b i32) - local.get $str1 - local.get $index1 - i32.const 1 - i32.shl - i32.add - local.set $ptr1 - local.get $str2 - local.get $index2 - i32.const 1 - i32.shl - i32.add - local.set $ptr2 - i32.const 0 - i32.const 2 - i32.lt_s - drop - local.get $len - i32.const 4 - i32.ge_u - if (result i32) - local.get $ptr1 - i32.const 7 - i32.and - local.get $ptr2 - i32.const 7 - i32.and - i32.or - i32.eqz - else - i32.const 0 - end - if - block $do-break|0 - loop $do-loop|0 - local.get $ptr1 - i64.load - local.get $ptr2 - i64.load - i64.ne - if - br $do-break|0 - end - local.get $ptr1 - i32.const 8 - i32.add - local.set $ptr1 - local.get $ptr2 - i32.const 8 - i32.add - local.set $ptr2 - local.get $len - i32.const 4 - i32.sub - local.set $len - local.get $len - i32.const 4 - i32.ge_u - br_if $do-loop|0 - end - end - end - loop $while-continue|1 - local.get $len - local.tee $7 - i32.const 1 - i32.sub - local.set $len - local.get $7 - if - local.get $ptr1 - i32.load16_u - local.set $a - local.get $ptr2 - i32.load16_u - local.set $b - local.get $a - local.get $b - i32.ne - if - local.get $a - local.get $b - i32.sub - return - end - local.get $ptr1 - i32.const 2 - i32.add - local.set $ptr1 - local.get $ptr2 - i32.const 2 - i32.add - local.set $ptr2 - br $while-continue|1 - end - end - i32.const 0 - return - ) - (func $assembly/arguments/Args#get:d (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/instructions/outcome/panic (result i32) - global.get $assembly/instructions/outcome/Result.PANIC - call $assembly/instructions/outcome/status - return - ) - (func $start:assembly/instructions/misc~anonymous|0 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/panic - ) - (func $start:assembly/instructions/misc~anonymous|1 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/panic - ) - (func $start:assembly/instructions/misc~anonymous|2 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/ok - ) - (func $assembly/memory/Memory#get:sbrkAddress (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/memory/Memory#get:lastAllocatedPage (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/Memory#get:arena (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/Instruction#set:namePtr (param $this i32) (param $namePtr i32) - local.get $this - local.get $namePtr - i32.store - ) - (func $assembly/instructions/Instruction#set:kind (param $this i32) (param $kind i32) - local.get $this - local.get $kind - i32.store offset=4 - ) - (func $assembly/instructions/Instruction#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/instructions/Instruction#set:isTerminating (param $this i32) (param $isTerminating i32) - local.get $this - local.get $isTerminating - i32.store8 offset=16 - ) - (func $assembly/instructions/Instruction#constructor (param $this i32) (result i32) - local.get $this - i32.eqz - if - i32.const 17 - call $~lib/rt/tlsf/__alloc - local.set $this - end - local.get $this - i32.const 0 - call $assembly/instructions/Instruction#set:namePtr - local.get $this - global.get $assembly/arguments/Arguments.Zero - call $assembly/instructions/Instruction#set:kind - local.get $this - i64.const 0 - call $assembly/instructions/Instruction#set:gas - local.get $this - i32.const 0 - call $assembly/instructions/Instruction#set:isTerminating - local.get $this - ) - (func $assembly/instructions/instruction (param $name i32) (param $kind i32) (param $gas i64) (param $isTerminating i32) (result i32) - (local $i i32) - i32.const 0 - call $assembly/instructions/Instruction#constructor - local.set $i - local.get $i - local.get $name - call $assembly/instructions/Instruction#set:namePtr - local.get $i - local.get $kind - call $assembly/instructions/Instruction#set:kind - local.get $i - local.get $gas - call $assembly/instructions/Instruction#set:gas - local.get $i - local.get $isTerminating - call $assembly/instructions/Instruction#set:isTerminating - local.get $i - return - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $start:assembly/program - call $start:assembly/instructions - ) - (func $assembly/program/Mask#set:bytesToSkip (param $this i32) (param $bytesToSkip i32) - local.get $this - local.get $bytesToSkip - i32.store - local.get $this - local.get $bytesToSkip - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Mask#get:bytesToSkip (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i32) (result i32) - (local $sign i32) - (local $dest i32) - (local $decimals i32) - (local $val32 i32) - (local $buffer|6 i32) - (local $num i32) - (local $offset i32) - i32.const 0 - local.set $sign - i32.const 0 - drop - local.get $buffer - local.get $sign - i32.const 1 - i32.shl - i32.add - local.set $dest - i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 0 - drop - local.get $value - i32.const 10 - i32.lt_u - if - local.get $buffer - local.get $value - i32.const 48 - i32.or - i32.store16 - i32.const 1 - return - end - i32.const 0 - local.set $decimals - i32.const 4 - i32.const 4 - i32.le_u - drop - local.get $value - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - local.get $dest - local.set $buffer|6 - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|6 - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - local.get $sign - local.get $decimals - i32.add - return - ) - (func $~lib/string/String#toString (param $this i32) (result i32) - local.get $this - return - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/Decoder#set:source (param $this i32) (param $source i32) - local.get $this - local.get $source - i32.store - local.get $this - local.get $source - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/codec/Decoder#set:offset (param $this i32) (param $offset i32) - local.get $this - local.get $offset - i32.store offset=4 - ) - (func $assembly/codec/Decoder#get:offset (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/Decoder#get:source (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/codec/ValOffset#set:value (param $this i32) (param $value i32) - local.get $this - local.get $value - i32.store - ) - (func $assembly/codec/ValOffset#set:offset (param $this i32) (param $offset i32) - local.get $this - local.get $offset - i32.store offset=4 - ) - (func $assembly/codec/ValOffset#get:offset (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/ValOffset#get:value (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/JumpTable#set:jumps (param $this i32) (param $jumps i32) - local.get $this - local.get $jumps - i32.store - local.get $this - local.get $jumps - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - ) - (func $assembly/instructions/Instruction#get:isTerminating (param $this i32) (result i32) - local.get $this - i32.load8_u offset=16 - ) - (func $assembly/program/BasicBlocks#set:isStartOrEnd (param $this i32) (param $isStartOrEnd i32) - local.get $this - local.get $isStartOrEnd - i32.store - local.get $this - local.get $isStartOrEnd - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:code (param $this i32) (param $code i32) - local.get $this - local.get $code - i32.store - local.get $this - local.get $code - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:mask (param $this i32) (param $mask i32) - local.get $this - local.get $mask - i32.store offset=4 - local.get $this - local.get $mask - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:jumpTable (param $this i32) (param $jumpTable i32) - local.get $this - local.get $jumpTable - i32.store offset=8 - local.get $this - local.get $jumpTable - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:basicBlocks (param $this i32) (param $basicBlocks i32) - local.get $this - local.get $basicBlocks - i32.store offset=12 - local.get $this - local.get $basicBlocks - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#get:mask (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/program/Program#get:jumpTable (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/program/JumpTable#get:jumps (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/Program#get:basicBlocks (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/program/BasicBlocks#get:isStartOrEnd (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $start:assembly/spi - i32.const 2 - i32.const 24 - call $~lib/math/ipow32 - global.set $assembly/spi/DATA_LENGTH - i32.const 2 - i32.const 32 - call $~lib/math/ipow32 - global.get $assembly/memory-page/SEGMENT_SIZE - i32.sub - global.get $assembly/spi/DATA_LENGTH - i32.sub - global.set $assembly/spi/ARGS_SEGMENT_START - i32.const 2 - i32.const 32 - call $~lib/math/ipow32 - i32.const 2 - global.get $assembly/memory-page/SEGMENT_SIZE - i32.mul - i32.sub - global.get $assembly/spi/DATA_LENGTH - i32.sub - global.set $assembly/spi/STACK_SEGMENT_END - ) - (func $assembly/spi/alignToSegmentSize (param $size i32) (result i32) - local.get $size - global.get $assembly/memory-page/SEGMENT_SIZE - i32.add - i32.const 1 - i32.sub - global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT - i32.shr_u - global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT - i32.shl - return - ) - (func $assembly/spi/alignToPageSize (param $size i32) (result i32) - local.get $size - global.get $assembly/memory-page/PAGE_SIZE - i32.add - i32.const 1 - i32.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - return - ) - (func $assembly/spi/StandardProgram#set:program (param $this i32) (param $program i32) - local.get $this - local.get $program - i32.store offset=16 - local.get $this - local.get $program - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:memory (param $this i32) (param $memory i32) - local.get $this - local.get $memory - i32.store offset=20 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:registers (param $this i32) (param $registers i32) - local.get $this - local.get $registers - i32.store offset=24 - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:metadata (param $this i32) (param $metadata i32) - local.get $this - local.get $metadata - i32.store - local.get $this - local.get $metadata - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store offset=4 - ) - (func $assembly/spi/StandardProgram#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/spi/StandardProgram#get:program (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $assembly/program/Program#get:code (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/spi/StandardProgram#get:memory (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $assembly/spi/StandardProgram#get:registers (param $this i32) (result i32) - local.get $this - i32.load offset=24 - ) - (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i64) (result i32) - (local $sign i32) - (local $dest i32) - (local $decimals i32) - (local $val32 i32) - (local $buffer|6 i32) - (local $num i32) - (local $offset i32) - (local $val64 i64) - (local $buffer|10 i32) - (local $num|11 i64) - (local $offset|12 i32) - i32.const 0 - local.set $sign - i32.const 0 - drop - local.get $buffer - local.get $sign - i32.const 1 - i32.shl - i32.add - local.set $dest - i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 0 - drop - local.get $value - i64.const 10 - i64.lt_u - if - local.get $buffer - local.get $value - i32.const 48 - i64.extend_i32_s - i64.or - i64.store16 - i32.const 1 - return - end - i32.const 0 - local.set $decimals - i32.const 8 - i32.const 4 - i32.le_u - drop - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - local.get $dest - local.set $buffer|6 - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|6 - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - local.set $val64 - local.get $val64 - call $~lib/util/number/decimalCount64High - local.set $decimals - local.get $dest - local.set $buffer|10 - local.get $val64 - local.set $num|11 - local.get $decimals - local.set $offset|12 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|10 - local.get $num|11 - local.get $offset|12 - call $~lib/util/number/utoa64_dec_lut - end - local.get $sign - local.get $decimals - i32.add - return - ) - (func $start:assembly/test-run - call $start:assembly/instructions/bit.test - call $start:assembly/instructions/branch.test - call $start:assembly/instructions/logic.test - call $start:assembly/instructions/math.test - call $start:assembly/instructions/rot.test - call $start:assembly/memory.test - call $start:assembly/program.test - call $start:assembly/spi.test - ) - (func $assembly/test/Test#get:name (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/test/Test#get:ptr (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/test/Assert#get:isOkay (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $~lib/rt/__visit_globals (param $0 i32) - (local $1 i32) - i32.const 480 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 1296 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 9584 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 21616 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 8624 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 288 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 2928 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 3984 - local.get $0 - call $~lib/rt/itcms/__visit - global.get $assembly/instructions/bit.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/branch.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/logic.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/math.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/rot.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/program.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/spi.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/RELEVANT_ARGS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/REQUIRED_BYTES - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/DECODERS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_PAGE - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions-exe/RUN - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/codec/MASKS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/INSTRUCTIONS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - ) - (func $~lib/arraybuffer/ArrayBufferView~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/object/Object~visit (param $0 i32) (param $1 i32) - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/typedarray/Uint8Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit - ) - (func $assembly/memory-page/Page~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory-page/RawPage~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/Memory~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory-page/Arena~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $"~lib/map/Map~visit" (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $"~lib/map/Map#__visit" - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit - ) - (func $assembly/test/Test~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/test/Assert~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array<~lib/string/String>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<~lib/string/String>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/memory/MemoryBuilder~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - i32.const 1 - drop - local.get $this - local.set $cur - local.get $cur - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray<~lib/string/String>#__visit - ) - (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#__visit - ) - (func $assembly/memory/Result~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/ChunkBytes~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/Chunks~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/PageData~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/typedarray/Uint8ClampedArray~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/function/Function<%28u8%29=>u8>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28u8%29=>u8>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28u8%29=>u8>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/program/Mask~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/program/Program~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/JumpTable~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/BasicBlocks~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/codec/Decoder~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/spi/StandardProgram~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=16 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=20 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=24 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/rt/__visit_members (param $0 i32) (param $1 i32) - block $invalid - block $assembly/spi/StandardProgram - block $assembly/codec/ValOffset - block $assembly/codec/Decoder - block $~lib/staticarray/StaticArray - block $assembly/program/BasicBlocks - block $assembly/program/JumpTable - block $assembly/program/Program - block $~lib/array/Array - block $~lib/array/Array - block $~lib/staticarray/StaticArray - block $assembly/program/Mask - block $~lib/array/Array - block $~lib/function/Function<%28u8%29=>u8> - block $~lib/array/Array - block $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> - block $~lib/typedarray/Uint8ClampedArray - block $assembly/memory/PageData - block $assembly/memory/Chunks - block $~lib/staticarray/StaticArray - block $assembly/memory/ChunkBytes - block $assembly/memory/Result - block $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert> - block $~lib/staticarray/StaticArray<~lib/string/String> - block $assembly/memory/MemoryBuilder - block $~lib/array/Array - block $~lib/array/Array<~lib/string/String> - block $assembly/test/Assert - block $assembly/test/Test - block $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> - block $assembly/instructions/outcome/OutcomeData - block $"~lib/map/Map" - block $~lib/array/Array - block $assembly/memory-page/Arena - block $assembly/memory/Memory - block $~lib/staticarray/StaticArray - block $assembly/memory-page/RawPage - block $assembly/memory-page/Page - block $assembly/memory/MaybePageFault - block $assembly/arguments/Nibbles - block $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> - block $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> - block $assembly/arguments/Args - block $~lib/typedarray/Uint8Array - block $~lib/array/Array - block $~lib/arraybuffer/ArrayBufferView - block $~lib/string/String - block $~lib/arraybuffer/ArrayBuffer - block $~lib/object/Object - local.get $0 - i32.const 8 - i32.sub - i32.load - br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $~lib/arraybuffer/ArrayBufferView $~lib/array/Array $~lib/typedarray/Uint8Array $assembly/arguments/Args $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $assembly/arguments/Nibbles $assembly/memory/MaybePageFault $assembly/memory-page/Page $assembly/memory-page/RawPage $~lib/staticarray/StaticArray $assembly/memory/Memory $assembly/memory-page/Arena $~lib/array/Array $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $assembly/test/Test $assembly/test/Assert $~lib/array/Array<~lib/string/String> $~lib/array/Array $assembly/memory/MemoryBuilder $~lib/staticarray/StaticArray<~lib/string/String> $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert> $assembly/memory/Result $assembly/memory/ChunkBytes $~lib/staticarray/StaticArray $assembly/memory/Chunks $assembly/memory/PageData $~lib/typedarray/Uint8ClampedArray $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $~lib/array/Array $~lib/function/Function<%28u8%29=>u8> $~lib/array/Array $assembly/program/Mask $~lib/staticarray/StaticArray $~lib/array/Array $~lib/array/Array $assembly/program/Program $assembly/program/JumpTable $assembly/program/BasicBlocks $~lib/staticarray/StaticArray $assembly/codec/Decoder $assembly/codec/ValOffset $assembly/spi/StandardProgram $invalid - end - return - end - return - end - return - end - local.get $0 - local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/typedarray/Uint8Array~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit - return - end - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/Page~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/RawPage~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory/Memory~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/Arena~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $"~lib/map/Map~visit" - return - end - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit - return - end - local.get $0 - local.get $1 - call $assembly/test/Test~visit - return - end - local.get $0 - local.get $1 - call $assembly/test/Assert~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/MemoryBuilder~visit - return - end - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray<~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/Result~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/ChunkBytes~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory/Chunks~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/PageData~visit - return - end - local.get $0 - local.get $1 - call $~lib/typedarray/Uint8ClampedArray~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28u8%29=>u8>~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/Mask~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/Program~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/JumpTable~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/BasicBlocks~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/codec/Decoder~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/spi/StandardProgram~visit - return - end - unreachable - ) - (func $~start - call $start:assembly/test-run - ) - (func $~stack_check - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__data_end - i32.lt_s - if - i32.const 60848 - i32.const 60896 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - ) - (func $assembly/arguments/Args#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 6 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:b - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:c - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:d - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/arguments/Args.from (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32) - (local $x i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $x - i32.store - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $a - call $assembly/arguments/Args#set:a - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $b - call $assembly/arguments/Args#set:b - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $c - call $assembly/arguments/Args#set:c - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $d - call $assembly/arguments/Args#set:d - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/typedarray/Uint8Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/typedarray/Uint8Array#subarray (param $this i32) (param $begin i32) (param $end i32) (result i32) - (local $array i32) - (local $begin|4 i32) - (local $end|5 i32) - (local $len i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $14 i32) - (local $15 i32) - (local $16 i32) - (local $out i32) - (local $buf i32) - (local $19 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - block $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $array - i32.store - local.get $begin - local.set $begin|4 - local.get $end - local.set $end|5 - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - local.get $begin|4 - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $begin|4 - i32.add - local.tee $7 - i32.const 0 - local.tee $8 - local.get $7 - local.get $8 - i32.gt_s - select - else - local.get $begin|4 - local.tee $9 - local.get $len - local.tee $10 - local.get $9 - local.get $10 - i32.lt_s - select - end - local.set $begin|4 - local.get $end|5 - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $end|5 - i32.add - local.tee $11 - i32.const 0 - local.tee $12 - local.get $11 - local.get $12 - i32.gt_s - select - else - local.get $end|5 - local.tee $13 - local.get $len - local.tee $14 - local.get $13 - local.get $14 - i32.lt_s - select - end - local.set $end|5 - local.get $end|5 - local.tee $15 - local.get $begin|4 - local.tee $16 - local.get $15 - local.get $16 - i32.gt_s - select - local.set $end|5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=8 - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $buf - local.get $out - local.get $buf - i32.store - local.get $out - local.get $buf - i32.const 0 - call $~lib/rt/itcms/__link - local.get $out - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $begin|4 - i32.const 0 - i32.shl - i32.add - i32.store offset=4 - local.get $out - local.get $end|5 - local.get $begin|4 - i32.sub - i32.const 0 - i32.shl - i32.store offset=8 - local.get $out - br $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" - end - local.set $19 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $19 - return - ) - (func $~lib/typedarray/Uint8Array#__get (param $this i32) (param $index i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - i32.ge_u - if - i32.const 480 - i32.const 720 - i32.const 167 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $index - i32.add - i32.load8_u - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/arguments/decodeI32 (param $input i32) (param $start i32) (param $end i32) (result i32) - (local $data i32) - (local $value1 f64) - (local $value2 f64) - (local $len i32) - (local $num i32) - (local $i i32) - (local $msb i32) - (local $prefix i32) - (local $i|11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $input - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $start - local.get $end - local.get $start - i32.gt_u - if (result i32) - local.get $end - else - local.get $start - end - call $~lib/typedarray/Uint8Array#subarray - local.tee $data - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.0 (result f64) - f64.const 4 - local.set $value1 - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.0 - end - i32.trunc_sat_f64_u - local.set $len - i32.const 0 - local.set $num - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_u - if - local.get $num - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.get $i - i32.const 8 - i32.mul - i32.shl - i32.or - local.set $num - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $len - i32.const 0 - i32.gt_u - if (result i32) - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $len - i32.const 1 - i32.sub - call $~lib/typedarray/Uint8Array#__get - i32.const 128 - i32.and - else - i32.const 0 - end - local.set $msb - local.get $msb - i32.const 0 - i32.gt_u - if (result i32) - i32.const 255 - else - i32.const 0 - end - local.set $prefix - local.get $len - local.set $i|11 - loop $for-loop|1 - local.get $i|11 - i32.const 4 - i32.lt_u - if - local.get $num - local.get $prefix - local.get $i|11 - i32.const 8 - i32.mul - i32.shl - i32.or - local.set $num - local.get $i|11 - i32.const 1 - i32.add - local.set $i|11 - br $for-loop|1 - end - end - local.get $num - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $start:assembly/arguments~anonymous|1 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/arguments/Nibbles#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 2 - i32.const 9 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Nibbles#set:low - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Nibbles#set:hig - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/arguments/nibbles (param $byte i32) (result i32) - (local $low i32) - (local $hig i32) - (local $n i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $byte - i32.const 15 - i32.and - local.set $low - local.get $byte - i32.const 255 - i32.and - i32.const 4 - i32.const 7 - i32.and - i32.shr_u - local.set $hig - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Nibbles#constructor - local.tee $n - i32.store - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $low - call $assembly/arguments/Nibbles#set:low - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $hig - call $assembly/arguments/Nibbles#set:hig - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/arguments/twoImm (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $first i32) - (local $second i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.1 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.1 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $first - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $second - local.get $first - local.get $second - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|2 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $lim - call $assembly/arguments/twoImm - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $start:assembly/arguments~anonymous|3 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/arguments~anonymous|4 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/typedarray/Uint8Array#subarray@varargs (param $this i32) (param $begin i32) (param $end i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $begin - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $begin - local.get $end - call $~lib/typedarray/Uint8Array#subarray - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/arguments/decodeU32 (param $data i32) (result i32) - (local $num i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 2 - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 3 - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - local.set $num - local.get $num - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/arguments~anonymous|5 (param $data i32) (param $_lim i32) (result i32) - (local $a i32) - (local $b i32) - (local $c i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Nibbles#get:low - local.set $a - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/decodeU32 - local.set $b - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 5 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/decodeU32 - local.set $c - local.get $a - i32.const 255 - i32.and - local.get $b - local.get $c - i32.const 0 - call $assembly/arguments/Args.from - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/arguments~anonymous|6 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $immA i32) - (local $immB i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.2 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.2 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $immA - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $immB - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $immA - local.get $immB - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|7 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $immA i32) - (local $offs i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.3 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.3 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $immA - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $offs - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $immA - local.get $offs - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|8 (param $data i32) (param $_lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|9 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|10 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|11 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - i32.const 1 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $lim - i32.const 1 - i32.gt_u - if (result i32) - local.get $lim - i32.const 1 - i32.sub - else - i32.const 0 - end - call $assembly/arguments/twoImm - local.tee $result - i32.store offset=12 - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:a - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/arguments/Args.from - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/arguments~anonymous|12 (param $data i32) (param $_lim i32) (result i32) - (local $a i32) - (local $b i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $a - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $b - i32.store offset=8 - local.get $a - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $a - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $b - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - i32.const 0 - call $assembly/arguments/Args.from - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/MaybePageFault#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 10 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:isFault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:isAccess - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:fault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/arraybuffer/ArrayBufferView#constructor (param $this i32) (param $length i32) (param $alignLog2 i32) (result i32) - (local $buffer i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 3 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:buffer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:byteLength - local.get $length - i32.const 1073741820 - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1344 - i32.const 19 - i32.const 57 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $length - local.get $alignLog2 - i32.shl - local.tee $length - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $buffer - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $~lib/arraybuffer/ArrayBufferView#set:buffer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $buffer - call $~lib/arraybuffer/ArrayBufferView#set:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $length - call $~lib/arraybuffer/ArrayBufferView#set:byteLength - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $length - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#constructor - local.tee $this - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/memory-page/Page#constructor (param $this i32) (param $access i32) (param $raw i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 11 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $access - call $assembly/memory-page/Page#set:access - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $raw - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory-page/Page#set:raw - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory-page/RawPage#constructor (param $this i32) (param $id i32) (param $page i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 12 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $id - call $assembly/memory-page/RawPage#set:id - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $page - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory-page/RawPage#set:page - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $start:assembly/memory - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - call $start:assembly/memory-page - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - global.set $assembly/memory/NO_PAGE_FAULT - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - global.set $assembly/memory/EMPTY_UINT8ARRAY - i32.const 0 - global.get $assembly/memory-page/Access.None - i32.const 0 - i32.const -1 - i32.const 0 - call $assembly/memory-page/RawPage#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/memory-page/Page#constructor - global.set $assembly/memory/EMPTY_PAGE - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i64) - (local $value i64) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/OutcomeData#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.const 18 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/instructions/outcome/Outcome.Ok - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:staticJump - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:dJump - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/instructions/outcome/Result.PANIC - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:exitCode - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/bit~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.popcnt - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.popcnt - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.clz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.clz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ctz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.ctz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u8SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u16SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|8 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.const 65535 - i32.and - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|9 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/polyfills/bswap - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $"~lib/map/Map#constructor" (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.const 17 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 4 - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - i32.const 1 - i32.sub - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 4 - block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.0" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesOffset" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/typedarray/Uint8Array.wrap (param $buffer i32) (param $byteOffset i32) (param $length i32) (result i32) - (local $buffer|3 i32) - (local $byteOffset|4 i32) - (local $len i32) - (local $byteLength i32) - (local $bufferByteLength i32) - (local $out i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - block $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $buffer - local.tee $buffer|3 - i32.store - local.get $byteOffset - local.set $byteOffset|4 - local.get $length - local.set $len - local.get $buffer|3 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/arraybuffer/ArrayBuffer#get:byteLength - local.set $bufferByteLength - local.get $byteOffset|4 - local.get $bufferByteLength - i32.gt_u - local.get $byteOffset|4 - i32.const 0 - i32.and - i32.or - if - i32.const 480 - i32.const 720 - i32.const 1860 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $len - i32.const 0 - i32.lt_s - if - local.get $len - i32.const -1 - i32.eq - if - local.get $bufferByteLength - i32.const 0 - i32.and - if - i32.const 1296 - i32.const 720 - i32.const 1865 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - local.get $bufferByteLength - local.get $byteOffset|4 - i32.sub - local.set $byteLength - else - i32.const 1296 - i32.const 720 - i32.const 1869 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - else - local.get $len - i32.const 0 - i32.shl - local.set $byteLength - local.get $byteOffset|4 - local.get $byteLength - i32.add - local.get $bufferByteLength - i32.gt_s - if - i32.const 1296 - i32.const 720 - i32.const 1874 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=8 - local.get $out - local.get $buffer|3 - i32.store - local.get $out - local.get $buffer|3 - i32.const 0 - call $~lib/rt/itcms/__link - local.get $out - local.get $byteLength - i32.store offset=8 - local.get $out - local.get $buffer|3 - local.get $byteOffset|4 - i32.add - i32.store offset=4 - local.get $out - br $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" - end - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $~lib/array/ensureCapacity (param $array i32) (param $newSize i32) (param $alignLog2 i32) (param $canGrow i32) - (local $oldCapacity i32) - (local $oldData i32) - (local $6 i32) - (local $7 i32) - (local $newCapacity i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $newData i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $array - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - local.set $oldCapacity - local.get $newSize - local.get $oldCapacity - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - local.get $newSize - i32.const 1073741820 - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1888 - i32.const 19 - i32.const 48 - call $~lib/builtins/abort - unreachable - end - local.get $array - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $oldData - local.get $newSize - local.tee $6 - i32.const 8 - local.tee $7 - local.get $6 - local.get $7 - i32.gt_u - select - local.get $alignLog2 - i32.shl - local.set $newCapacity - local.get $canGrow - if - local.get $oldCapacity - i32.const 1 - i32.shl - local.tee $9 - i32.const 1073741820 - local.tee $10 - local.get $9 - local.get $10 - i32.lt_u - select - local.tee $11 - local.get $newCapacity - local.tee $12 - local.get $11 - local.get $12 - i32.gt_u - select - local.set $newCapacity - end - local.get $oldData - local.get $newCapacity - call $~lib/rt/itcms/__renew - local.set $newData - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $newData - local.get $oldData - i32.ne - if - local.get $array - local.get $newData - i32.store - local.get $array - local.get $newData - i32.store offset=4 - local.get $array - local.get $newData - i32.const 0 - call $~lib/rt/itcms/__link - end - local.get $array - local.get $newCapacity - i32.store offset=8 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#unshift (param $this i32) (param $value i32) (result i32) - (local $len i32) - (local $ptr i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.set $ptr - local.get $ptr - i32.const 4 - i32.add - local.get $ptr - local.get $len - i32.const 1 - i32.sub - i32.const 2 - i32.shl - memory.copy - local.get $ptr - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory-page/Arena#constructor (param $this i32) (param $pageCount i32) (result i32) - (local $2 i32) - (local $data i32) - (local $i i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 15 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:free - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:arenaBytes - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:extraPageIndex - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/memory-page/PAGE_SIZE - local.get $pageCount - i32.mul - call $assembly/memory-page/Arena#set:arenaBytes - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - i32.const 2 - i32.const 16 - i32.const 1856 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory-page/Arena#set:free - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pageCount - call $assembly/memory-page/Arena#set:extraPageIndex - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory-page/Arena#get:arenaBytes - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $data - i32.store offset=12 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pageCount - i32.lt_s - if - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory-page/Arena#get:free - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - local.get $i - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array.wrap - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory-page/RawPage#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/array/Array#unshift - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/memory/MemoryBuilder#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 24 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#constructor" - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/MemoryBuilder#set:pages - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 128 - call $assembly/memory-page/Arena#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/MemoryBuilder#set:arena - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $"~lib/map/Map#find" (param $this i32) (param $key i32) (param $hashCode i32) (result i32) - (local $entry i32) - (local $taggedNext i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - i32.load - local.set $entry - loop $while-continue|0 - local.get $entry - if - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - local.set $taggedNext - local.get $taggedNext - i32.const 1 - i32.and - i32.eqz - if (result i32) - local.get $entry - call $"~lib/map/MapEntry#get:key" - local.get $key - i32.eq - else - i32.const 0 - end - if - local.get $entry - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $taggedNext - i32.const 1 - i32.const -1 - i32.xor - i32.and - local.set $entry - br $while-continue|0 - end - end - i32.const 0 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $"~lib/map/Map#has" (param $this i32) (param $key i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $key - local.get $key - call $~lib/util/hash/HASH - call $"~lib/map/Map#find" - i32.const 0 - i32.ne - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/Memory#constructor (param $this i32) (param $arena i32) (param $pages i32) (param $sbrkAddress i32) (result i32) - (local $sbrkPage i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 14 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $arena - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory/Memory#set:arena - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory/Memory#set:pages - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $sbrkAddress - call $assembly/memory/Memory#set:sbrkAddress - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $sbrkAddress - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $sbrkPage - local.get $sbrkPage - global.get $assembly/memory-page/RESERVED_PAGES - i32.lt_u - if - i32.const 1936 - i32.const 2048 - i32.const 119 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $sbrkPage - call $"~lib/map/Map#has" - if (result i32) - local.get $sbrkPage - else - local.get $sbrkPage - i32.const 1 - i32.sub - end - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/memory/MemoryBuilder#build (param $this i32) (param $sbrkAddress i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - i32.const 0 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MemoryBuilder#get:arena - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MemoryBuilder#get:pages - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $sbrkAddress - call $assembly/memory/Memory#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/MemoryBuilder#build@varargs (param $this i32) (param $sbrkAddress i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - global.get $assembly/memory-page/RESERVED_MEMORY - local.set $sbrkAddress - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $sbrkAddress - call $assembly/memory/MemoryBuilder#build - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/test/Assert#constructor (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 21 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 1 - call $assembly/test/Assert#set:isOkay - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.const 2 - i32.const 22 - i32.const 2112 - call $~lib/rt/__newArray - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/test/Assert#set:errors - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/util/string/joinStringArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $4 i32) - (local $estLen i32) - (local $value i32) - (local $i i32) - (local $offset i32) - (local $sepLen i32) - (local $result i32) - (local $i|11 i32) - (local $valueLen i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - end - local.get $lastIndex - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - i32.load - local.tee $4 - i32.store - local.get $4 - if (result i32) - local.get $4 - else - i32.const 4080 - end - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - end - i32.const 0 - local.set $estLen - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $i - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $estLen - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - i32.add - local.set $estLen - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $offset - local.get $separator - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - local.set $sepLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - local.get $sepLen - local.get $lastIndex - i32.mul - i32.add - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=12 - i32.const 0 - local.set $i|11 - loop $for-loop|1 - local.get $i|11 - local.get $lastIndex - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $i|11 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - local.set $valueLen - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value - local.get $valueLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $valueLen - i32.add - local.set $offset - end - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i|11 - i32.const 1 - i32.add - local.set $i|11 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $lastIndex - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - memory.copy - end - local.get $result - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - i32.const 1 - i32.lt_s - drop - i32.const 1 - drop - local.get $this - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/staticarray/StaticArray<~lib/string/String>#get:length - local.get $separator - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/util/string/joinStringArray - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/array/Array<~lib/string/String>#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array<~lib/string/String>#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array<~lib/string/String>#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) - (local $4 i32) - (local $5 i32) - (local $actualDisplay i32) - (local $7 i32) - (local $8 i32) - (local $expectDisplay i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $actual - local.get $expected - i32.ne - if - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 10 - call $~lib/number/I32#toString - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 16 - call $~lib/number/I32#toString - local.tee $5 - i32.store offset=8 - i32.const 2256 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $4 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 2256 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $5 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 2256 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $actualDisplay - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 10 - call $~lib/number/I32#toString - local.tee $7 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 16 - call $~lib/number/I32#toString - local.tee $8 - i32.store offset=24 - i32.const 4112 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $7 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4112 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $8 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4112 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $expectDisplay - i32.store offset=28 - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - call $assembly/test/Assert#get:errors - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $10 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $12 - i32.store offset=44 - i32.const 4272 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 1 - local.get $10 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4272 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 3 - local.get $11 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4272 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 5 - local.get $12 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4272 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i64) (param $expected i64) (param $msg i32) - (local $4 i32) - (local $5 i32) - (local $actualDisplay i32) - (local $7 i32) - (local $8 i32) - (local $expectDisplay i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $actual - local.get $expected - i64.ne - if - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 10 - call $~lib/number/U64#toString - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 16 - call $~lib/number/U64#toString - local.tee $5 - i32.store offset=8 - i32.const 4320 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $4 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4320 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $5 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4320 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $actualDisplay - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 10 - call $~lib/number/U64#toString - local.tee $7 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 16 - call $~lib/number/U64#toString - local.tee $8 - i32.store offset=24 - i32.const 4368 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $7 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4368 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $8 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4368 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $expectDisplay - i32.store offset=28 - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - call $assembly/test/Assert#get:errors - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $10 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $12 - i32.store offset=44 - i32.const 4416 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 1 - local.get $10 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4416 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 3 - local.get $11 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4416 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 5 - local.get $12 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4416 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit.test~anonymous|0 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281470681747729 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/count_set_bits_64 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 2 - i64.const 8 - i64.mul - i64.const 4 - i64.add - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/test/Test#constructor (param $this i32) (param $name i32) (param $ptr i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 20 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $name - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/test/Test#set:name - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $ptr - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/test/Test#set:ptr - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/test/test (param $name i32) (param $ptr i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 0 - local.get $name - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $ptr - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/test/Test#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|1 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281470681747729 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/count_set_bits_32 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 4 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|2 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281406257234193 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/leading_zero_bits_64 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 16 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|3 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281470681747729 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/leading_zero_bits_32 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 19 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|4 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281406257233920 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/trailing_zero_bits_64 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 36 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|5 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281406257233920 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/trailing_zero_bits_32 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 32 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|6 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/sign_extend_8 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -17 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|7 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/sign_extend_16 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -16657 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|8 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/zero_extend_16 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 48879 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i64) (param $expected i64) (param $msg i32) - (local $4 i32) - (local $5 i32) - (local $actualDisplay i32) - (local $7 i32) - (local $8 i32) - (local $expectDisplay i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $actual - local.get $expected - i64.ne - if - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 10 - call $~lib/number/I64#toString - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 16 - call $~lib/number/I64#toString - local.tee $5 - i32.store offset=8 - i32.const 5264 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $4 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5264 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $5 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5264 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $actualDisplay - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 10 - call $~lib/number/I64#toString - local.tee $7 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 16 - call $~lib/number/I64#toString - local.tee $8 - i32.store offset=24 - i32.const 5312 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $7 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5312 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $8 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5312 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $expectDisplay - i32.store offset=28 - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - call $assembly/test/Assert#get:errors - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $10 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $12 - i32.store offset=44 - i32.const 5360 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 1 - local.get $10 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5360 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 3 - local.get $11 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5360 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 5 - local.get $12 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5360 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit.test~anonymous|9 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281409993162479 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/reverse_bytes - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1171307680032161792 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 1888 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - call $start:assembly/arguments - call $start:assembly/memory - global.get $~lib/memory/__stack_pointer - i32.const 10 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 1792 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4464 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 4496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4560 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 4592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4656 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - i32.const 4688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4752 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - i32.const 4784 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4848 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 5 - i32.const 4880 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4944 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 6 - i32.const 4976 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 5024 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 7 - i32.const 5056 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 5104 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 8 - i32.const 5136 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 5184 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 9 - i32.const 5216 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 5408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/bit.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/staticJump (param $offset i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.StaticJump - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $offset - call $assembly/instructions/outcome/OutcomeData#set:staticJump - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/branch~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.eq - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.ne - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.lt_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.le_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.ge_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.gt_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.lt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.le_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.ge_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.gt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.eq - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ne - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_u - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ge_u - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ge_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) - (local $4 i32) - (local $5 i32) - (local $actualDisplay i32) - (local $7 i32) - (local $8 i32) - (local $expectDisplay i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $actual - local.get $expected - i32.ne - if - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 10 - call $~lib/number/U32#toString - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 16 - call $~lib/number/U32#toString - local.tee $5 - i32.store offset=8 - i32.const 6048 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $4 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6048 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $5 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6048 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $actualDisplay - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 10 - call $~lib/number/U32#toString - local.tee $7 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 16 - call $~lib/number/U32#toString - local.tee $8 - i32.store offset=24 - i32.const 6096 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $7 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6096 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $8 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6096 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $expectDisplay - i32.store offset=28 - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - call $assembly/test/Assert#get:errors - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $10 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $12 - i32.store offset=44 - i32.const 6144 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 1 - local.get $10 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6144 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 3 - local.get $11 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6144 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 5 - local.get $12 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6144 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch.test~anonymous|0 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 254 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const -559038737 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 254 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/branch/branch_eq_imm - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.StaticJump - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:staticJump - i32.const -559038737 - i32.const 6000 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/branch.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 1 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 5952 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 6192 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/branch.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.xor - i64.const -1 - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic.test~anonymous|0 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 3 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 15 - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 263882790666241 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/logic/and_inv - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 263882790666240 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/logic.test~anonymous|1 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 3 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 15 - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 263882790666241 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/logic/or_inv - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -15 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/logic.test~anonymous|2 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 3 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 15 - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 263882790666240 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/logic/xnor - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -263882790666256 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/logic.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 3 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 6512 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 6560 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 6592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 6624 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 6656 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 6688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/logic.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $c i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $c - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $c - i64.add - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.mul - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.const 4294967296 - i64.or - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i32.add - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 2 - i64.const 32 - call $~lib/math/ipow64 - i64.add - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - i64.sub - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.mul - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i32.div_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i32.MIN_VALUE - i64.extend_i32_s - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i32.rem_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i32) - (local $a i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i32.const -1 - i32.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i32.MIN_VALUE - i32.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - i64.extend_i32_s - local.get $a - i64.extend_i32_s - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.div_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i64.MIN_VALUE - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|18 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.rem_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|19 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i64.MIN_VALUE - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|20 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperSigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|21 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperUnsigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|22 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperSignedUnsigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|23 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.lt_s - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|24 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.lt_u - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|25 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.gt_s - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|26 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.gt_u - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math.test~anonymous|0 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 3 - i32.const 0 - call $assembly/arguments/Args.from - local.tee $args - i32.store - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=4 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/math/max - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 2 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/math.test~anonymous|1 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 3 - i32.const 0 - call $assembly/arguments/Args.from - local.tee $args - i32.store - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=4 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/math/max_u - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/math.test~anonymous|2 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 3 - i32.const 0 - call $assembly/arguments/Args.from - local.tee $args - i32.store - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=4 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/math/min - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/math.test~anonymous|3 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 3 - i32.const 0 - call $assembly/arguments/Args.from - local.tee $args - i32.store - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=4 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/math/min_u - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 2 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/math.test~anonymous|4 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 3 - i32.const 0 - call $assembly/arguments/Args.from - local.tee $args - i32.store - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=4 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - i64.const 64 - call $~lib/math/ipow64 - i64.const 1 - i64.sub - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - i64.const 64 - call $~lib/math/ipow64 - i64.const 1 - i64.sub - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/math/add_32 - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -2 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/math.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 5 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 7584 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 7616 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 7648 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 7680 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 7712 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 7744 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - i32.const 7776 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 7808 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - i32.const 7840 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 7872 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/math.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_l - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_l_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot.test~anonymous|0 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 8 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/rot/rot_r_64_imm - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1224979098630181442 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/rot.test~anonymous|1 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const -559038737 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 8 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/rot/rot_r_64_imm_alt - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1152921504609030722 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/rot.test~anonymous|2 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 8 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 8 - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/rot/rot_l_64 - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 956397711104 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/rot.test~anonymous|3 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 8 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 8 - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/rot/rot_l_32 - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1379995682 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/rot.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 8160 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 8208 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 8240 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 8304 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 8336 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 8384 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - i32.const 8416 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 8464 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/rot.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Chunks#constructor (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 30 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:fault - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:first - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:second - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory/Chunks#constructor@varargs (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $first - i32.store - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $second - i32.store offset=4 - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - local.get $first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - local.get $second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - local.get $4 - call $assembly/memory/Chunks#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory/PageData#constructor (param $this i32) (param $fault i32) (param $page i32) (param $relativeAddress i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 31 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/PageData#set:fault - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $page - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/PageData#set:page - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $relativeAddress - call $assembly/memory/PageData#set:relativeAddress - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory/fault (param $address i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isFault - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $address - call $assembly/memory/MaybePageFault#set:fault - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $"~lib/map/Map#get" (param $this i32) (param $key i32) (result i32) - (local $entry i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $key - local.get $key - call $~lib/util/hash/HASH - call $"~lib/map/Map#find" - local.set $entry - local.get $entry - i32.eqz - if - i32.const 8624 - i32.const 8688 - i32.const 105 - i32.const 17 - call $~lib/builtins/abort - unreachable - end - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory-page/Page#can (param $this i32) (param $access i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/Page#get:access - global.get $assembly/memory-page/Access.Write - i32.eq - if (result i32) - i32.const 1 - else - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/Page#get:access - local.get $access - i32.eq - end - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/Memory#getPage (param $this i32) (param $access i32) (param $address i32) (result i32) - (local $pageIdx i32) - (local $relAddress i32) - (local $pageStart i32) - (local $page i32) - (local $f i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $address - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $pageIdx - local.get $address - global.get $assembly/memory-page/PAGE_SIZE - i32.rem_u - local.set $relAddress - local.get $pageIdx - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - local.set $pageStart - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/memory/Memory#get:pages - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $pageIdx - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.get $pageStart - call $assembly/memory/fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory/EMPTY_PAGE - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/memory/Memory#get:pages - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $pageIdx - call $"~lib/map/Map#get" - local.tee $page - i32.store offset=8 - local.get $page - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $access - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $pageStart - call $assembly/memory/fault - local.tee $f - i32.store offset=12 - local.get $f - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isAccess - i32.const 0 - local.get $f - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory/EMPTY_PAGE - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $page - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/typedarray/Uint8Array#fill (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $value - local.get $start - local.get $end - call $~lib/util/bytes/FILL - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/typedarray/Uint8Array#fill@varargs (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $value - local.get $start - local.get $end - call $~lib/typedarray/Uint8Array#fill - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory-page/RawPage#get:data (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:page - i32.const 0 - i32.eq - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory-page/RawPage#set:page - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:page - local.tee $1 - i32.store offset=12 - local.get $1 - if (result i32) - local.get $1 - else - i32.const 8736 - i32.const 8864 - i32.const 46 - i32.const 12 - call $~lib/builtins/abort - unreachable - end - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/Memory#getChunks (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) - (local $pageData i32) - (local $page i32) - (local $relativeAddress i32) - (local $endAddress i32) - (local $needSecondPage i32) - (local $first i32) - (local $secondPageIdx i32) - (local $secondPageStart i32) - (local $secondPage i32) - (local $f i32) - (local $firstChunk i32) - (local $secondChunk i32) - (local $16 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $bytes - i32.const 255 - i32.and - i32.const 0 - i32.eq - if - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $access - local.get $address - call $assembly/memory/Memory#getPage - local.tee $pageData - i32.store offset=4 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/PageData#get:fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/MaybePageFault#get:isFault - if - i32.const 0 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/PageData#get:fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/PageData#get:page - local.tee $page - i32.store offset=12 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/PageData#get:relativeAddress - local.set $relativeAddress - local.get $relativeAddress - local.get $bytes - i32.const 255 - i32.and - i32.add - local.set $endAddress - local.get $endAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.gt_u - local.set $needSecondPage - local.get $needSecondPage - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $page - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $relativeAddress - local.get $endAddress - call $~lib/typedarray/Uint8Array#subarray - local.tee $first - i32.store offset=20 - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $first - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - i32.const 2 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - local.get $address - local.get $bytes - i32.const 255 - i32.and - i32.add - i64.extend_i32_u - global.get $assembly/memory/MEMORY_SIZE - i64.rem_s - i32.wrap_i64 - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $secondPageIdx - local.get $secondPageIdx - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - local.set $secondPageStart - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/Memory#get:pages - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $secondPageIdx - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.get $secondPageStart - call $assembly/memory/fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/Memory#get:pages - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $secondPageIdx - call $"~lib/map/Map#get" - local.tee $secondPage - i32.store offset=24 - local.get $secondPage - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $access - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $secondPageStart - call $assembly/memory/fault - local.tee $f - i32.store offset=28 - local.get $f - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isAccess - i32.const 0 - local.get $f - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $page - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $relativeAddress - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $firstChunk - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $secondPage - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - local.get $relativeAddress - local.get $bytes - i32.const 255 - i32.and - i32.add - global.get $assembly/memory-page/PAGE_SIZE - i32.sub - call $~lib/typedarray/Uint8Array#subarray - local.tee $secondChunk - i32.store offset=36 - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $firstChunk - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - local.get $secondChunk - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory/Chunks#constructor - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - ) - (func $assembly/memory/ChunkBytes#constructor (param $this i32) (param $fault i32) (param $bytes i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 28 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $fault - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory/ChunkBytes#set:fault - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $bytes - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory/ChunkBytes#set:bytes - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/ChunkBytes#constructor@varargs (param $this i32) (param $fault i32) (param $bytes i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/staticarray/StaticArray#constructor - local.tee $bytes - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $fault - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $bytes - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/memory/ChunkBytes#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/getBytes (param $bytes i32) (param $first i32) (param $second i32) (result i32) - (local $res i32) - (local $len i32) - (local $i i32) - (local $i|6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $bytes - i32.const 255 - i32.and - call $~lib/staticarray/StaticArray#constructor - local.tee $res - i32.store - local.get $first - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $i - local.get $first - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|6 - loop $for-loop|1 - local.get $i|6 - local.get $second - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $len - local.get $i|6 - i32.add - local.get $second - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - local.get $i|6 - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $i|6 - i32.const 1 - i32.add - local.set $i|6 - br $for-loop|1 - end - end - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $assembly/memory/Memory#getBytes (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) - (local $res i32) - (local $data i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $access - local.get $address - local.get $bytes - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $assembly/memory/MaybePageFault#get:isFault - if - i32.const 0 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/ChunkBytes#constructor@varargs - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - global.get $~lib/memory/__stack_pointer - local.get $bytes - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:first - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:second - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/getBytes - local.tee $data - i32.store offset=16 - i32.const 0 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/ChunkBytes#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/memory/Result#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 27 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/memory/Result#set:ok - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/Result#set:fault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory/Memory#getI8 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/u8SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU64 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 8 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 8 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 16 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 24 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 4 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 32 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 5 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 40 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 6 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 48 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 7 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 56 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) - (local $4 i32) - (local $5 i32) - (local $actualDisplay i32) - (local $7 i32) - (local $8 i32) - (local $expectDisplay i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $actual - i32.const 0 - i32.ne - local.get $expected - i32.const 0 - i32.ne - i32.ne - if - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 0 - call $~lib/number/Bool#toString - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 16 - call $~lib/number/Bool#toString - local.tee $5 - i32.store offset=8 - i32.const 8992 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $4 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 8992 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $5 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 8992 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $actualDisplay - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 0 - call $~lib/number/Bool#toString - local.tee $7 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 16 - call $~lib/number/Bool#toString - local.tee $8 - i32.store offset=24 - i32.const 9104 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $7 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 9104 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $8 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 9104 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $expectDisplay - i32.store offset=28 - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - call $assembly/test/Assert#get:errors - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $10 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $12 - i32.store offset=44 - i32.const 9152 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 1 - local.get $10 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 9152 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 3 - local.get $11 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 9152 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 5 - local.get $12 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 9152 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/memory.test~anonymous|0 (param $$0 i32) (result i32) - (local $mem i32) - (local $a i32) - (local $b i32) - (local $assert i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $mem - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $assembly/memory/Memory#getI8 - local.tee $a - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - global.get $assembly/memory-page/RESERVED_MEMORY - i32.const 1 - i32.sub - call $assembly/memory/Memory#getU64 - local.tee $b - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=16 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $a - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 1 - i32.const 8944 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $a - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9200 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $a - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:fault - i32.const 0 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $b - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 1 - i32.const 9248 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $b - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9296 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $b - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:fault - i32.const 61440 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/string/String#concat (param $this i32) (param $other i32) (result i32) - (local $thisSize i32) - (local $otherSize i32) - (local $outSize i32) - (local $out i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $thisSize - local.get $other - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $otherSize - local.get $thisSize - local.get $otherSize - i32.add - local.set $outSize - local.get $outSize - i32.const 0 - i32.eq - if - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $out - local.get $this - local.get $thisSize - memory.copy - local.get $out - local.get $thisSize - i32.add - local.get $other - local.get $otherSize - memory.copy - local.get $out - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#pop (param $this i32) (result i32) - (local $len i32) - (local $val i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - local.set $len - local.get $len - i32.const 1 - i32.lt_s - if - i32.const 9584 - i32.const 1888 - i32.const 271 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $len - i32.const 1 - i32.sub - local.tee $len - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $val - i32.store offset=4 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $len - call $~lib/array/Array#set:length_ - local.get $val - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/console/console.log (param $message i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $message - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/bindings/dom/console.log - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory-page/Arena#acquire (param $this i32) (result i32) - (local $allocatedMemory i32) - (local $data i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:free - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - i32.const 0 - i32.gt_s - if - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:free - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#pop - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.set $allocatedMemory - local.get $allocatedMemory - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/Arena#get:arenaBytes - i32.eq - if - i32.const 9632 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/console/console.log - end - global.get $~lib/memory/__stack_pointer - local.get $allocatedMemory - global.get $assembly/memory-page/ALLOCATE_EAGERLY - i32.lt_u - if (result i32) - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - else - i32.const 0 - end - local.tee $data - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - i32.const 1 - i32.add - call $assembly/memory-page/Arena#set:extraPageIndex - i32.const 0 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/RawPage#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) - (local $newBucketsCapacity i32) - (local $newBuckets i32) - (local $newEntriesCapacity i32) - (local $newEntries i32) - (local $oldPtr i32) - (local $oldEnd i32) - (local $newPtr i32) - (local $oldEntry i32) - (local $newEntry i32) - (local $oldEntryKey i32) - (local $newBucketIndex i32) - (local $newBucketPtrBase i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $newBucketsMask - i32.const 1 - i32.add - local.set $newBucketsCapacity - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newBucketsCapacity - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newBuckets - i32.store - local.get $newBucketsCapacity - i32.const 8 - i32.mul - i32.const 3 - i32.div_s - local.set $newEntriesCapacity - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newEntriesCapacity - block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.1" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newEntries - i32.store offset=4 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entries" - local.set $oldPtr - local.get $oldPtr - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.2" - end - i32.mul - i32.add - local.set $oldEnd - local.get $newEntries - local.set $newPtr - loop $while-continue|0 - local.get $oldPtr - local.get $oldEnd - i32.ne - if - local.get $oldPtr - local.set $oldEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $newPtr - local.set $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:key" - local.set $oldEntryKey - local.get $newEntry - local.get $oldEntryKey - call $"~lib/map/MapEntry#set:key" - local.get $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:value" - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/MapEntry#set:value" - local.get $oldEntryKey - call $~lib/util/hash/HASH - local.get $newBucketsMask - i32.and - local.set $newBucketIndex - local.get $newBuckets - local.get $newBucketIndex - i32.const 4 - i32.mul - i32.add - local.set $newBucketPtrBase - local.get $newEntry - local.get $newBucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $newBucketPtrBase - local.get $newPtr - i32.store - local.get $newPtr - block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.3" - end - i32.add - local.set $newPtr - end - local.get $oldPtr - block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.4" - end - i32.add - local.set $oldPtr - br $while-continue|0 - end - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBuckets - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBucketsMask - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntries - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntriesCapacity - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#get:entriesCount" - call $"~lib/map/Map#set:entriesOffset" - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) - (local $hashCode i32) - (local $entry i32) - (local $entries i32) - (local $6 i32) - (local $bucketPtrBase i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $key - call $~lib/util/hash/HASH - local.set $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $key - local.get $hashCode - call $"~lib/map/Map#find" - local.set $entry - local.get $entry - if - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.eq - if - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.const 3 - i32.mul - i32.const 4 - i32.div_s - i32.lt_s - if (result i32) - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.const 1 - i32.shl - i32.const 1 - i32.or - end - call $"~lib/map/Map#rehash" - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.tee $entries - i32.store offset=8 - local.get $entries - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.tee $6 - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesOffset" - local.get $6 - block $"~lib/map/ENTRY_SIZE|inlined.5" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.5" - end - i32.mul - i32.add - local.set $entry - local.get $entry - local.get $key - call $"~lib/map/MapEntry#set:key" - i32.const 0 - drop - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - local.set $bucketPtrBase - local.get $entry - local.get $bucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $bucketPtrBase - local.get $entry - i32.store - end - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/memory/MemoryBuilder#getOrCreatePageForAddress (param $this i32) (param $access i32) (param $address i32) (result i32) - (local $pageIdx i32) - (local $page i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $address - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $pageIdx - local.get $pageIdx - global.get $assembly/memory-page/RESERVED_PAGES - i32.lt_u - if - i32.const 9488 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - i32.const 10 - call $~lib/number/U32#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/string/String#concat - i32.const 2048 - i32.const 93 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/MemoryBuilder#get:pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/MemoryBuilder#get:arena - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=8 - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/MemoryBuilder#get:pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - i32.const 0 - local.get $access - local.get $page - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory-page/Page#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $"~lib/map/Map#set" - drop - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/MemoryBuilder#get:pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - call $"~lib/map/Map#get" - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.set $sourceStart - i32.const 0 - i32.eqz - drop - local.get $targetStart - local.get $sourceStart - local.get $sourceLen - i32.const 0 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MemoryBuilder#setData (param $this i32) (param $access i32) (param $address i32) (param $data i32) (result i32) - (local $currentAddress i32) - (local $currentData i32) - (local $page i32) - (local $relAddress i32) - (local $spaceInPage i32) - (local $end i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $address - local.set $currentAddress - global.get $~lib/memory/__stack_pointer - local.get $data - local.tee $currentData - i32.store - loop $while-continue|0 - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $access - local.get $currentAddress - call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress - local.tee $page - i32.store offset=8 - local.get $currentAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.rem_u - local.set $relAddress - global.get $assembly/memory-page/PAGE_SIZE - local.get $relAddress - i32.sub - local.set $spaceInPage - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - local.get $spaceInPage - i32.lt_u - if (result i32) - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - else - local.get $spaceInPage - end - local.set $end - local.get $page - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $10 - call $assembly/memory-page/Page#get:raw - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - call $assembly/memory-page/RawPage#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - i32.const 0 - local.get $end - call $~lib/typedarray/Uint8Array#subarray - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - local.get $relAddress - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $currentAddress - local.get $end - i32.add - local.set $currentAddress - global.get $~lib/memory/__stack_pointer - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $end - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $currentData - i32.store - br $while-continue|0 - end - end - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $assembly/memory/Memory#getU8 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/typedarray/Uint8Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - i32.ge_u - if - i32.const 480 - i32.const 720 - i32.const 178 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $index - i32.add - local.get $value - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU8 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 1 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/memory.test~anonymous|1 (param $$0 i32) (result i32) - (local $builder i32) - (local $mem i32) - (local $a i32) - (local $b i32) - (local $c i32) - (local $d i32) - (local $assert i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store - local.get $builder - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $assembly/memory-page/Access.Read - global.get $assembly/memory-page/RESERVED_MEMORY - i32.const 0 - i32.const 10 - call $~lib/typedarray/Uint8Array#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/MemoryBuilder#setData - drop - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $mem - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $assembly/memory-page/RESERVED_MEMORY - call $assembly/memory/Memory#getU64 - local.tee $a - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $assembly/memory-page/RESERVED_PAGES - i32.const 1 - i32.add - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - call $assembly/memory/Memory#getU8 - local.tee $b - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $assembly/memory-page/RESERVED_MEMORY - i32.const 12 - call $assembly/memory/Memory#setU8 - local.tee $c - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $assembly/memory-page/RESERVED_MEMORY - call $assembly/memory/Memory#getU8 - local.tee $d - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=32 - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $a - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=40 - local.get $8 - call $assembly/memory/Result#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 8944 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $a - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=40 - local.get $8 - call $assembly/memory/Result#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9200 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $a - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/Result#get:ok - i64.const 0 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $b - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=40 - local.get $8 - call $assembly/memory/Result#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 1 - i32.const 9248 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $b - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=40 - local.get $8 - call $assembly/memory/Result#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9296 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $b - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=40 - local.get $8 - call $assembly/memory/Result#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:fault - i32.const 69632 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 1 - i32.const 9728 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 1 - i32.const 9776 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:fault - i32.const 65536 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $d - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/Result#get:ok - i64.const 0 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $i i32) - (local $ptr i32) - (local $value i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/array/Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/array/Array#get:dataStart - local.set $sourceStart - i32.const 0 - i32.const 2 - i32.eq - drop - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $sourceLen - i32.lt_s - if - local.get $targetStart - local.get $i - i32.const 0 - i32.shl - i32.add - local.set $ptr - local.get $sourceStart - local.get $i - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - i32.const 0 - drop - local.get $ptr - local.get $value - i32.store8 - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#bytesWrite (param $this i32) (param $address i32) (param $source i32) (result i32) - (local $nextAddress i32) - (local $sourceIndex i32) - (local $bytesLeft i32) - (local $pageData i32) - (local $relAddress i32) - (local $bytesToWrite i32) - (local $sourceData i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - local.get $address - local.set $nextAddress - i32.const 0 - local.set $sourceIndex - loop $while-continue|0 - local.get $sourceIndex - local.get $source - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $source - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - local.get $sourceIndex - i32.sub - local.set $bytesLeft - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - global.get $assembly/memory-page/Access.Write - local.get $nextAddress - call $assembly/memory/Memory#getPage - local.tee $pageData - i32.store offset=4 - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/PageData#get:fault - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:fault - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - end - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:relativeAddress - local.set $relAddress - local.get $relAddress - local.get $bytesLeft - i32.add - global.get $assembly/memory-page/PAGE_SIZE - i32.lt_u - if (result i32) - local.get $bytesLeft - else - global.get $assembly/memory-page/PAGE_SIZE - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:relativeAddress - i32.sub - end - local.set $bytesToWrite - global.get $~lib/memory/__stack_pointer - local.get $source - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $sourceIndex - local.get $sourceIndex - local.get $bytesToWrite - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $sourceData - i32.store offset=12 - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=24 - local.get $10 - call $assembly/memory/PageData#get:page - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $10 - call $assembly/memory-page/Page#get:raw - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - call $assembly/memory-page/RawPage#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $sourceData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - local.get $relAddress - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $sourceIndex - local.get $bytesToWrite - i32.add - local.set $sourceIndex - local.get $nextAddress - local.get $bytesToWrite - i32.add - local.set $nextAddress - br $while-continue|0 - end - end - global.get $assembly/memory/NO_PAGE_FAULT - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $assembly/memory/Memory#bytesRead (param $this i32) (param $address i32) (param $destination i32) (result i32) - (local $nextAddress i32) - (local $destinationIndex i32) - (local $bytesLeft i32) - (local $pageData i32) - (local $relAddress i32) - (local $bytesToRead i32) - (local $source i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $address - local.set $nextAddress - i32.const 0 - local.set $destinationIndex - loop $while-continue|0 - local.get $destinationIndex - local.get $destination - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $destination - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - local.get $destinationIndex - i32.sub - local.set $bytesLeft - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - global.get $assembly/memory-page/Access.Read - local.get $nextAddress - call $assembly/memory/Memory#getPage - local.tee $pageData - i32.store offset=4 - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/PageData#get:fault - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:fault - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - end - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:relativeAddress - local.set $relAddress - local.get $relAddress - local.get $bytesLeft - i32.add - global.get $assembly/memory-page/PAGE_SIZE - i32.lt_u - if (result i32) - local.get $bytesLeft - else - global.get $assembly/memory-page/PAGE_SIZE - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:relativeAddress - i32.sub - end - local.set $bytesToRead - global.get $~lib/memory/__stack_pointer - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - call $assembly/memory/PageData#get:page - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/memory-page/Page#get:raw - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory-page/RawPage#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $relAddress - local.get $relAddress - local.get $bytesToRead - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $source - i32.store offset=20 - local.get $destination - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $source - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - local.get $destinationIndex - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $destinationIndex - local.get $bytesToRead - i32.add - local.set $destinationIndex - local.get $nextAddress - local.get $bytesToRead - i32.add - local.set $nextAddress - br $while-continue|0 - end - end - global.get $assembly/memory/NO_PAGE_FAULT - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $~lib/string/String#substring (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $len i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $finalStart i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $finalEnd i32) - (local $14 i32) - (local $15 i32) - (local $fromPos i32) - (local $17 i32) - (local $18 i32) - (local $toPos i32) - (local $size i32) - (local $out i32) - (local $22 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $~lib/string/String#get:length - local.set $len - local.get $start - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - local.tee $6 - local.get $len - local.tee $7 - local.get $6 - local.get $7 - i32.lt_s - select - local.set $finalStart - local.get $end - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_s - select - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - local.set $finalEnd - local.get $finalStart - local.tee $14 - local.get $finalEnd - local.tee $15 - local.get $14 - local.get $15 - i32.lt_s - select - i32.const 1 - i32.shl - local.set $fromPos - local.get $finalStart - local.tee $17 - local.get $finalEnd - local.tee $18 - local.get $17 - local.get $18 - i32.gt_s - select - i32.const 1 - i32.shl - local.set $toPos - local.get $toPos - local.get $fromPos - i32.sub - local.set $size - local.get $size - i32.eqz - if - i32.const 4080 - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - end - local.get $fromPos - i32.eqz - if (result i32) - local.get $toPos - local.get $len - i32.const 1 - i32.shl - i32.eq - else - i32.const 0 - end - if - local.get $this - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - end - global.get $~lib/memory/__stack_pointer - local.get $size - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $out - local.get $this - local.get $fromPos - i32.add - local.get $size - memory.copy - local.get $out - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - ) - (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $value i32) - (local $sepLen i32) - (local $estLen i32) - (local $result i32) - (local $offset i32) - (local $value|9 i32) - (local $i i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 4080 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $lastIndex - i32.eqz - if - local.get $dataStart - i32.load8_u - local.set $value - i32.const 0 - drop - i32.const 1 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 10 - call $~lib/util/number/utoa32 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $separator - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - local.set $sepLen - i32.const 10 - local.get $sepLen - i32.add - local.get $lastIndex - i32.mul - i32.const 10 - i32.add - local.set $estLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=4 - i32.const 0 - local.set $offset - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $lastIndex - i32.lt_s - if - local.get $dataStart - local.get $i - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $dataStart - local.get $lastIndex - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $estLen - local.get $offset - i32.gt_s - if - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.const 0 - local.get $offset - call $~lib/string/String#substring - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/typedarray/Uint8Array#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/typedarray/Uint8Array#get:length - local.get $separator - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/util/string/joinIntegerArray - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/typedarray/Uint8Array#toString (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 10000 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/typedarray/Uint8Array#join - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/string/String.__eq (param $left i32) (param $right i32) (result i32) - (local $leftLength i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $left - local.get $right - i32.eq - if - i32.const 1 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $left - i32.const 0 - i32.eq - if (result i32) - i32.const 1 - else - local.get $right - i32.const 0 - i32.eq - end - if - i32.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $left - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/string/String#get:length - local.set $leftLength - local.get $leftLength - local.get $right - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/string/String#get:length - i32.ne - if - i32.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $left - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - local.get $right - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - local.get $leftLength - call $~lib/util/string/compareImpl - i32.eqz - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/string/String.__ne (param $left i32) (param $right i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $left - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $right - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/string/String.__eq - i32.eqz - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/test/Assert#isEqual<~lib/string/String> (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) - (local $actualDisplay i32) - (local $expectDisplay i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - local.get $actual - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $expected - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/string/String.__ne - if - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - local.get $actual - local.tee $actualDisplay - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $expected - local.tee $expectDisplay - i32.store offset=12 - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - call $assembly/test/Assert#get:errors - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $6 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $7 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $8 - i32.store offset=28 - i32.const 10128 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 1 - local.get $6 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=32 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 10128 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 3 - local.get $7 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=32 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 10128 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 5 - local.get $8 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=32 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 10128 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 4080 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=32 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/memory.test~anonymous|2 (param $$0 i32) (result i32) - (local $builder i32) - (local $mem i32) - (local $out i32) - (local $data i32) - (local $5 i32) - (local $a i32) - (local $b i32) - (local $c i32) - (local $assert i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - global.get $assembly/memory-page/Access.Write - global.get $assembly/memory-page/RESERVED_MEMORY - i32.const 0 - i32.const 1 - call $~lib/typedarray/Uint8Array#constructor - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/MemoryBuilder#setData - drop - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - global.get $assembly/memory-page/Access.Write - global.get $assembly/memory-page/RESERVED_PAGES - i32.const 1 - i32.add - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - i32.const 0 - i32.const 1 - call $~lib/typedarray/Uint8Array#constructor - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/MemoryBuilder#setData - drop - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $mem - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 16 - call $~lib/typedarray/Uint8Array#constructor - local.tee $out - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $out - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $data - i32.store offset=20 - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - i32.const 4 - i32.const 2 - i32.const 4 - i32.const 9952 - call $~lib/rt/__newArray - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - i32.const 0 - call $~lib/typedarray/Uint8Array#set<~lib/array/Array> - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/PAGE_SIZE - i32.add - i32.const 10 - i32.sub - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/Memory#bytesWrite - local.tee $a - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/PAGE_SIZE - i32.add - i32.const 9 - i32.sub - local.get $out - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/Memory#bytesRead - local.tee $b - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/PAGE_SIZE - i32.const 2 - i32.mul - i32.add - local.get $out - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/Memory#bytesRead - local.tee $c - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=36 - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $a - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 8944 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $a - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9200 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $a - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:fault - i32.const 0 - i32.const 8944 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $b - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 9248 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $b - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9296 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $b - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:fault - i32.const 0 - i32.const 9248 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $c - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 1 - i32.const 9728 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $c - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9776 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $out - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=48 - local.get $10 - call $~lib/typedarray/Uint8Array#toString - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - i32.const 10032 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - i32.const 4080 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=44 - local.get $10 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=48 - local.get $10 - call $~lib/typedarray/Uint8Array#toString - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - i32.const 10176 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - i32.const 4080 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=44 - local.get $10 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $start:assembly/memory.test~anonymous|3 (param $$0 i32) (result i32) - (local $mem i32) - (local $out i32) - (local $a i32) - (local $b i32) - (local $c i32) - (local $d i32) - (local $e i32) - (local $assert i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - global.get $assembly/memory-page/Access.Read - global.get $assembly/memory-page/RESERVED_MEMORY - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MemoryBuilder#setData - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $mem - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.tee $out - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - local.get $out - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/memory/Memory#bytesRead - local.tee $a - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - local.get $out - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/memory/Memory#bytesWrite - local.tee $b - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/RESERVED_MEMORY - i32.add - local.get $out - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/memory/Memory#bytesRead - local.tee $c - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/RESERVED_MEMORY - i32.add - local.get $out - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/memory/Memory#bytesRead - local.tee $d - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - global.get $assembly/memory-page/RESERVED_MEMORY - local.get $out - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/memory/Memory#bytesWrite - local.tee $e - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=40 - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $a - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 8944 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $b - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 9248 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $c - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 9728 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $d - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 10448 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $e - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 10496 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $start:assembly/memory.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 8496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 9344 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 9376 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 9824 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 9856 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 10288 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - i32.const 10320 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 10544 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/memory.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/jump~anonymous|0 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:a - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/instructions/outcome/dJump (param $address i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.DynamicJump - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $address - call $assembly/instructions/outcome/OutcomeData#set:dJump - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/jump~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $address i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - local.get $address - call $assembly/instructions/outcome/dJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/jump~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/jump~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $address i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:d - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - local.get $address - call $assembly/instructions/outcome/dJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.const 32 - i64.shl - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/load~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/instructions/outcome/okOrFault (param $pageFault i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MaybePageFault#get:isAccess - if (result i32) - global.get $assembly/instructions/outcome/Result.FAULT_ACCESS - else - global.get $assembly/instructions/outcome/Result.FAULT - end - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MaybePageFault#get:fault - call $assembly/instructions/outcome/OutcomeData#set:exitCode - end - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/load~anonymous|2 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|3 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU16 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getI16 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $l i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/Result#set:fault - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.const 15 - i32.and - i32.shl - i32.or - local.set $l - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $l - call $assembly/instructions/utils/u16SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU32 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getI32 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $l i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/Result#set:fault - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i32.or - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i32.or - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i32.or - local.set $l - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $l - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU64 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU64 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/mov~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/set~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.lt_u - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.lt_s - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.gt_u - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.gt_s - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_u - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/set~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_s - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/shift~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $imm i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $imm - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $imm - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $regValue i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $regValue - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regValue - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|0 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU16 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 2 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.gt_s - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $value - i32.const 65535 - i32.and - i32.const 8 - i32.const 15 - i32.and - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - else - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 65535 - i32.and - i32.const 8 - i32.const 15 - i32.and - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|1 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU32 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $v i32) - (local $len i32) - (local $i i32) - (local $i|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 4 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $value - local.set $v - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - local.get $v - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i32.const 8 - i32.shr_u - local.set $v - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i|7 - local.get $v - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i32.const 8 - i32.shr_u - local.set $v - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/instructions/store~anonymous|2 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#setU32 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU64 (param $this i32) (param $address i32) (param $value i64) (result i32) - (local $res i32) - (local $v i64) - (local $len i32) - (local $i i32) - (local $i|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 8 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $value - local.set $v - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - local.get $v - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i64.const 8 - i64.shr_u - local.set $v - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i|7 - local.get $v - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i64.const 8 - i64.shr_u - local.set $v - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/instructions/store~anonymous|3 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Memory#setU64 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/memory/Memory#setU32 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Memory#setU64 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/instructions/outcome/status (param $result i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $result - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Result.HOST - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $id - call $assembly/instructions/outcome/OutcomeData#set:exitCode - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:a - call $assembly/instructions/outcome/hostCall - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) - (local $freeMemoryStart i32) - (local $newSbrk i64) - (local $pageIdx i32) - (local $i i32) - (local $page i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $freeMemoryStart - i32.store - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $amount - i32.const 0 - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - local.get $amount - i64.extend_i32_u - i64.add - local.set $newSbrk - local.get $newSbrk - global.get $assembly/memory/MEMORY_SIZE - i64.ge_s - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Result#get:fault - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isFault - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $newSbrk - i32.wrap_i64 - call $assembly/memory/Memory#set:sbrkAddress - local.get $newSbrk - i64.const 1 - i64.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - local.set $pageIdx - local.get $pageIdx - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.const 1 - i32.add - local.set $i - loop $for-loop|0 - local.get $i - local.get $pageIdx - i32.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:arena - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=12 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory/Memory#get:pages - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $i - i32.const 0 - global.get $assembly/memory-page/Access.Write - local.get $page - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory-page/Page#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $"~lib/map/Map#set" - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $pageIdx - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#sbrk - local.tee $res - i32.store offset=12 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/codec~anonymous|0 (param $firstByte i32) (result i32) - (local $len i32) - (local $i i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $assembly/codec/MASKS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.const 255 - i32.and - i32.lt_u - if - local.get $firstByte - i32.const 255 - i32.and - global.get $assembly/codec/MASKS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $i - call $~lib/array/Array#__get - i32.ge_u - if - i32.const 8 - local.get $i - i32.sub - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 1888 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 13920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/MISSING_INSTRUCTION - i32.const 13968 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/SBRK - global.get $~lib/memory/__stack_pointer - i32.const 231 - i32.const 2 - i32.const 36 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.const 14000 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 14032 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 5 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 6 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 7 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 8 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 9 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 10 - i32.const 14080 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 11 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 12 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 13 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 14 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 15 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 16 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 17 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 18 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 19 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 20 - i32.const 14112 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneExtImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 21 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 22 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 23 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 24 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 25 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 26 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 27 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 28 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 29 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 30 - i32.const 14160 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 31 - i32.const 14208 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 32 - i32.const 14256 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 33 - i32.const 14304 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 34 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 35 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 36 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 37 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 38 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 39 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 40 - i32.const 14352 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 41 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 42 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 43 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 44 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 45 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 46 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 47 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 48 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 49 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 50 - i32.const 14384 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 51 - i32.const 14432 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 52 - i32.const 14480 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 53 - i32.const 14528 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 54 - i32.const 14576 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 55 - i32.const 14624 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 56 - i32.const 14672 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 57 - i32.const 14720 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 58 - i32.const 14768 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 59 - i32.const 14816 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 60 - i32.const 14864 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 61 - i32.const 14912 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 62 - i32.const 14960 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 63 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 64 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 65 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 66 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 67 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 68 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 69 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 70 - i32.const 15008 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 71 - i32.const 15072 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 72 - i32.const 15136 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 73 - i32.const 15200 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 74 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 75 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 76 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 77 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 78 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 79 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 80 - i32.const 15264 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 81 - i32.const 15312 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 82 - i32.const 15360 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 83 - i32.const 15408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 84 - i32.const 15472 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 85 - i32.const 15536 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 86 - i32.const 15600 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 87 - i32.const 15664 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 88 - i32.const 15728 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 89 - i32.const 15792 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 90 - i32.const 15856 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 91 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 92 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 93 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 94 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 95 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 96 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 97 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 98 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 99 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 100 - i32.const 15920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 101 - global.get $assembly/instructions/SBRK - call $~lib/array/Array#__set - local.get $0 - i32.const 102 - i32.const 15968 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 103 - i32.const 16032 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 104 - i32.const 16096 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 105 - i32.const 16160 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 106 - i32.const 16224 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 107 - i32.const 16288 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 108 - i32.const 16352 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 109 - i32.const 16400 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 110 - i32.const 16448 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 111 - i32.const 16496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 112 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 113 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 114 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 115 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 116 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 117 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 118 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 119 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 120 - i32.const 16544 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 121 - i32.const 16592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 122 - i32.const 16640 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 123 - i32.const 16688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 124 - i32.const 16736 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 125 - i32.const 16784 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 126 - i32.const 16832 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 127 - i32.const 16880 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 128 - i32.const 16928 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 129 - i32.const 16976 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 130 - i32.const 17024 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 131 - i32.const 17072 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 132 - i32.const 17120 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 133 - i32.const 17168 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 134 - i32.const 17216 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 135 - i32.const 17248 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 136 - i32.const 17296 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 137 - i32.const 17344 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 138 - i32.const 17392 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 139 - i32.const 17440 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 140 - i32.const 17488 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 141 - i32.const 17536 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 142 - i32.const 17584 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 143 - i32.const 17632 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 144 - i32.const 17680 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 145 - i32.const 17744 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 146 - i32.const 17808 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 147 - i32.const 17872 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 148 - i32.const 17920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 149 - i32.const 17968 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 150 - i32.const 18016 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 151 - i32.const 18064 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 152 - i32.const 18112 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 153 - i32.const 18160 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 154 - i32.const 18208 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 155 - i32.const 18256 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 156 - i32.const 18320 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 157 - i32.const 18384 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 158 - i32.const 18448 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 159 - i32.const 18496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 160 - i32.const 18560 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 161 - i32.const 18608 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 162 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 163 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 164 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 165 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 166 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 167 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 168 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 169 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 170 - i32.const 18672 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 171 - i32.const 18720 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 172 - i32.const 18768 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 173 - i32.const 18816 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 174 - i32.const 18864 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 175 - i32.const 18912 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 176 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 177 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 178 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 179 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 180 - i32.const 18960 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegTwoImm - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 181 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 182 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 183 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 184 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 185 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 186 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 187 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 188 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 189 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 190 - i32.const 19024 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 191 - i32.const 19056 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 192 - i32.const 19088 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 193 - i32.const 19120 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 194 - i32.const 19168 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 195 - i32.const 19216 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 196 - i32.const 19264 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 197 - i32.const 19312 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 198 - i32.const 19360 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 199 - i32.const 19408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 200 - i32.const 19456 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 201 - i32.const 19488 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 202 - i32.const 19520 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 203 - i32.const 19552 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 204 - i32.const 19600 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 205 - i32.const 19648 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 206 - i32.const 19696 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 207 - i32.const 19744 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 208 - i32.const 19792 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 209 - i32.const 19840 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 210 - i32.const 19888 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 211 - i32.const 19920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 212 - i32.const 19952 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 213 - i32.const 19984 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 214 - i32.const 20032 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 215 - i32.const 20080 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 216 - i32.const 20128 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 217 - i32.const 20176 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 218 - i32.const 20224 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 219 - i32.const 20272 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 220 - i32.const 20320 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 221 - i32.const 20368 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 222 - i32.const 20416 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 223 - i32.const 20464 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 224 - i32.const 20512 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 225 - i32.const 20560 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 226 - i32.const 20592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 227 - i32.const 20624 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 228 - i32.const 20656 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 229 - i32.const 20688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 230 - i32.const 20720 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/INSTRUCTIONS - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/Mask#constructor (param $this i32) (param $packedMask i32) (param $codeLength i32) (result i32) - (local $lastInstructionOffset i32) - (local $i i32) - (local $bits i32) - (local $index i32) - (local $b i32) - (local $isSet i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 37 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - call $assembly/program/Mask#set:bytesToSkip - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - local.get $codeLength - call $~lib/staticarray/StaticArray#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/Mask#set:bytesToSkip - i32.const 0 - local.set $lastInstructionOffset - local.get $packedMask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.sub - local.set $i - loop $for-loop|0 - local.get $i - i32.const 0 - i32.ge_s - if - local.get $packedMask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $bits - local.get $i - i32.const 8 - i32.mul - local.set $index - i32.const 7 - local.set $b - loop $for-loop|2 - local.get $b - i32.const 0 - i32.ge_s - if - local.get $bits - i32.const 128 - i32.and - local.set $isSet - local.get $bits - i32.const 1 - i32.const 7 - i32.and - i32.shl - local.set $bits - local.get $index - local.get $b - i32.add - local.get $codeLength - i32.lt_s - if - local.get $isSet - if (result i32) - i32.const 0 - else - local.get $lastInstructionOffset - i32.const 1 - i32.add - end - local.set $lastInstructionOffset - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/Mask#get:bytesToSkip - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $index - local.get $b - i32.add - local.get $lastInstructionOffset - global.get $assembly/program/MAX_SKIP - i32.const 1 - i32.add - i32.lt_u - if (result i32) - local.get $lastInstructionOffset - else - global.get $assembly/program/MAX_SKIP - i32.const 1 - i32.add - end - call $~lib/staticarray/StaticArray#__set - end - local.get $b - i32.const 1 - i32.sub - local.set $b - br $for-loop|2 - end - end - local.get $i - i32.const 1 - i32.sub - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $i i32) - (local $ptr i32) - (local $value f64) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/array/Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/array/Array#get:dataStart - local.set $sourceStart - i32.const 1 - i32.const 0 - i32.eq - drop - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $sourceLen - i32.lt_s - if - local.get $targetStart - local.get $i - i32.const 0 - i32.shl - i32.add - local.set $ptr - local.get $sourceStart - local.get $i - i32.const 3 - i32.shl - i32.add - f64.load - local.set $value - i32.const 0 - drop - i32.const 0 - i32.eqz - drop - local.get $ptr - local.get $value - local.get $value - f64.sub - f64.const 0 - f64.eq - if (result i32) - local.get $value - i32.trunc_sat_f64_u - else - i32.const 0 - end - i32.store8 - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program.test/u8arr (param $data i32) (result i32) - (local $ret i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $ret - i32.store offset=4 - local.get $ret - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#set<~lib/array/Array> - local.get $ret - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/staticarray/StaticArray#slice<~lib/array/Array> (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $length i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $sourceStart i32) - (local $size i32) - (local $out i32) - (local $outStart i32) - (local $18 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $18 - global.get $~lib/memory/__stack_pointer - local.get $18 - i32.store - local.get $18 - call $~lib/staticarray/StaticArray#get:length - local.set $length - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $start - local.get $length - i32.add - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - else - local.get $start - local.tee $6 - local.get $length - local.tee $7 - local.get $6 - local.get $7 - i32.lt_s - select - end - local.set $start - local.get $end - i32.const 0 - i32.lt_s - if (result i32) - local.get $end - local.get $length - i32.add - local.tee $8 - i32.const 0 - local.tee $9 - local.get $8 - local.get $9 - i32.gt_s - select - else - local.get $end - local.tee $10 - local.get $length - local.tee $11 - local.get $10 - local.get $11 - i32.lt_s - select - end - local.set $end - local.get $end - local.get $start - i32.sub - local.tee $12 - i32.const 0 - local.tee $13 - local.get $12 - local.get $13 - i32.gt_s - select - local.set $length - local.get $this - local.get $start - i32.const 2 - i32.shl - i32.add - local.set $sourceStart - local.get $length - i32.const 2 - i32.shl - local.set $size - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $out - i32.store offset=4 - i32.const 1 - drop - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 2 - i32.const 40 - i32.const 0 - call $~lib/rt/__newArray - local.tee $out - i32.store offset=4 - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - local.get $18 - i32.store - local.get $18 - call $~lib/array/Array#get:dataStart - local.set $outStart - i32.const 0 - drop - local.get $outStart - local.get $sourceStart - local.get $size - memory.copy - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - ) - (func $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $start - local.get $end - call $~lib/staticarray/StaticArray#slice<~lib/array/Array> - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $value i32) - (local $sepLen i32) - (local $estLen i32) - (local $result i32) - (local $offset i32) - (local $value|9 i32) - (local $i i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 4080 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $lastIndex - i32.eqz - if - local.get $dataStart - i32.load - local.set $value - i32.const 0 - drop - i32.const 4 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 10 - call $~lib/util/number/utoa32 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $separator - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - local.set $sepLen - i32.const 10 - local.get $sepLen - i32.add - local.get $lastIndex - i32.mul - i32.const 10 - i32.add - local.set $estLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=4 - i32.const 0 - local.set $offset - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $lastIndex - i32.lt_s - if - local.get $dataStart - local.get $i - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $dataStart - local.get $lastIndex - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $estLen - local.get $offset - i32.gt_s - if - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.const 0 - local.get $offset - call $~lib/string/String#substring - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/array/Array#join (param $this i32) (param $separator i32) (result i32) - (local $ptr i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.set $ptr - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $len - i32.const 0 - drop - i32.const 1 - drop - local.get $ptr - local.get $len - local.get $separator - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/util/string/joinIntegerArray - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/test/Assert#isArrayEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $actual - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $~lib/array/Array#get:length - local.get $expected - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $~lib/array/Array#get:length - i32.const 21008 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $msg - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $~lib/string/String#concat - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/test/Assert#isEqual - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $actual - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - local.get $4 - i32.const 10000 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=24 - local.get $4 - call $~lib/array/Array#join - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $~lib/string/String#toString - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $expected - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - local.get $4 - i32.const 10000 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=24 - local.get $4 - call $~lib/array/Array#join - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $~lib/string/String#toString - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $msg - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/test/Assert#isEqual<~lib/string/String> - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/Mask#isInstruction (param $this i32) (param $index i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - i64.extend_i32_u - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i64.extend_i32_s - i64.ge_u - if - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $index - call $~lib/staticarray/StaticArray#__get - i32.const 0 - i32.eq - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/program/Mask#skipBytesToNextInstruction (param $this i32) (param $i i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $i - i32.const 1 - i32.add - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i32.lt_u - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $i - i32.const 1 - i32.add - call $~lib/staticarray/StaticArray#__get - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/program.test~anonymous|0 (param $$0 i32) (result i32) - (local $1 i32) - (local $mask i32) - (local $assert i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 3 - i32.const 3 - i32.const 39 - i32.const 20848 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program.test/u8arr - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 21 - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/program/Mask#get:bytesToSkip - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - i32.const 0 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 21 - i32.const 2 - i32.const 40 - i32.const 20896 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isArrayEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 0 - call $assembly/program/Mask#isInstruction - i32.const 0 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 4 - call $assembly/program/Mask#isInstruction - i32.const 1 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 20 - call $assembly/program/Mask#skipBytesToNextInstruction - i32.const 0 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 22 - call $assembly/program/Mask#skipBytesToNextInstruction - i32.const 0 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/program.test~anonymous|1 (param $$0 i32) (result i32) - (local $1 i32) - (local $mask i32) - (local $assert i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 4 - i32.const 3 - i32.const 39 - i32.const 21200 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program.test/u8arr - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 32 - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/program/Mask#get:bytesToSkip - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - i32.const 0 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 32 - i32.const 2 - i32.const 40 - i32.const 21264 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isArrayEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 21616 - i32.const 1888 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/decodeArguments (param $kind i32) (param $data i32) (param $lim i32) (result i32) - (local $extended i32) - (local $i i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - global.get $assembly/arguments/REQUIRED_BYTES - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $kind - call $~lib/array/Array#__get - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/arguments/REQUIRED_BYTES - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $kind - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#constructor - local.tee $extended - i32.store offset=4 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $extended - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $extended - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $lim - i32.const 2 - global.set $~argumentsLength - global.get $assembly/arguments/DECODERS - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $kind - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $3) - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $lim - i32.const 2 - global.set $~argumentsLength - global.get $assembly/arguments/DECODERS - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $kind - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $3) - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/program.test~anonymous|2 (param $$0 i32) (result i32) - (local $1 i32) - (local $data i32) - (local $args i32) - (local $assert i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 3 - i32.const 39 - i32.const 21552 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program.test/u8arr - local.tee $data - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - global.get $assembly/arguments/Arguments.OneImm - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 4 - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:a - i32.const -1 - i32.const 21744 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 0 - i32.const 21776 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 0 - i32.const 21808 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:d - i32.const 0 - i32.const 21840 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/program.test~anonymous|3 (param $$0 i32) (result i32) - (local $1 i32) - (local $data i32) - (local $args i32) - (local $assert i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 2 - i32.const 3 - i32.const 39 - i32.const 22000 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program.test/u8arr - local.tee $data - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - global.get $assembly/arguments/Arguments.OneImm - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:a - i32.const 5 - i32.const 21744 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 0 - i32.const 21776 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 0 - i32.const 21808 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:d - i32.const 0 - i32.const 21840 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/codec/Decoder#constructor (param $this i32) (param $source i32) (param $offset i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 45 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $source - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/codec/Decoder#set:source - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $offset - call $assembly/codec/Decoder#set:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/codec/Decoder#ensureBytes (param $this i32) (param $need i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#get:offset - local.get $need - i32.add - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/codec/Decoder#get:source - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $need - i32.const 10 - call $~lib/number/U32#toString - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/codec/Decoder#get:source - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#get:offset - i32.sub - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=12 - i32.const 22624 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $2 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 22624 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 3 - local.get $3 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 22624 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 4080 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 22672 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/ValOffset#constructor (param $this i32) (param $value i32) (param $offset i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 46 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $value - call $assembly/codec/ValOffset#set:value - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $offset - call $assembly/codec/ValOffset#set:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/codec/decodeVarU32 (param $data i32) (result i32) - (local $length i32) - (local $first i32) - (local $3 i32) - (local $4 i32) - (local $msb i32) - (local $number i32) - (local $i i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - i32.const 1 - global.set $~argumentsLength - global.get $assembly/codec/variableLength - i32.load - call_indirect (type $0) - i32.const 255 - i32.and - local.set $length - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $first - local.get $length - i32.const 0 - i32.eq - if - i32.const 0 - local.get $first - i32.const 1 - call $assembly/codec/ValOffset#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.get $length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.const 10 - call $~lib/number/I32#toString - local.tee $4 - i32.store offset=8 - i32.const 22896 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $3 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 22896 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 3 - local.get $4 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 22896 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 22672 - i32.const 108 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $first - i32.const 2 - i32.const 8 - local.get $length - i32.sub - call $~lib/math/ipow32 - i32.add - i32.const 2 - i32.const 8 - call $~lib/math/ipow32 - i32.sub - local.get $length - i32.const 8 - i32.mul - i32.shl - local.set $msb - i32.const 0 - local.set $number - local.get $length - i32.const 1 - i32.sub - local.set $i - loop $for-loop|0 - local.get $i - i32.const 0 - i32.ge_s - if - local.get $number - i32.const 8 - i32.shl - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $i - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.add - local.set $number - local.get $i - i32.const 1 - i32.sub - local.set $i - br $for-loop|0 - end - end - local.get $number - local.get $msb - i32.add - local.set $number - i32.const 0 - local.get $number - i32.const 1 - local.get $length - i32.add - call $assembly/codec/ValOffset#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/codec/Decoder#varU32 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/decodeVarU32 - local.tee $v - i32.store offset=12 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/ValOffset#get:offset - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/ValOffset#get:value - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u8 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#bytes (param $this i32) (param $len i32) (result i32) - (local $v i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $len - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:source - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $len - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $v - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $len - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/JumpTable#constructor (param $this i32) (param $itemBytes i32) (param $data i32) (result i32) - (local $jumps i32) - (local $i i32) - (local $num i64) - (local $j i32) - (local $nextNum i64) - (local $isOverflow i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 42 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - call $assembly/program/JumpTable#set:jumps - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $itemBytes - i32.const 255 - i32.and - i32.const 0 - i32.gt_u - if (result i32) - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.get $itemBytes - i32.const 255 - i32.and - i32.div_s - else - i32.const 0 - end - call $~lib/staticarray/StaticArray#constructor - local.tee $jumps - i32.store offset=8 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - i64.const 0 - local.set $num - local.get $itemBytes - i32.const 1 - i32.sub - i32.const 255 - i32.and - local.set $j - loop $for-loop|1 - local.get $j - i32.const 0 - i32.ge_s - if - local.get $num - i64.const 8 - i64.shl - local.set $nextNum - local.get $nextNum - local.get $num - i64.lt_u - local.set $isOverflow - local.get $nextNum - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - local.get $j - i32.add - call $~lib/typedarray/Uint8Array#__get - i64.extend_i32_u - i64.add - local.set $nextNum - local.get $isOverflow - if (result i32) - i32.const 1 - else - local.get $nextNum - local.get $num - i64.lt_u - end - local.set $isOverflow - local.get $isOverflow - if (result i64) - global.get $~lib/builtins/u64.MAX_VALUE - else - local.get $nextNum - end - local.set $num - local.get $j - i32.const 1 - i32.sub - local.set $j - br $for-loop|1 - end - end - local.get $jumps - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - local.get $itemBytes - i32.const 255 - i32.and - i32.div_s - local.get $num - call $~lib/staticarray/StaticArray#__set - local.get $i - local.get $itemBytes - i32.const 255 - i32.and - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $jumps - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $assembly/program/JumpTable#set:jumps - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 21616 - i32.const 1888 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/BasicBlocks#constructor (param $this i32) (param $code i32) (param $mask i32) (result i32) - (local $len i32) - (local $isStartOrEnd i32) - (local $n i32) - (local $isInstructionInMask i32) - (local $skipArgs i32) - (local $iData i32) - (local $isTerminating i32) - (local $newBlockStart i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 43 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - call $assembly/program/BasicBlocks#set:isStartOrEnd - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $len - call $~lib/staticarray/StaticArray#constructor - local.tee $isStartOrEnd - i32.store offset=8 - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set - i32.const 0 - local.set $n - loop $for-loop|0 - local.get $n - local.get $len - i32.lt_s - if - block $for-continue|0 - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $assembly/program/Mask#isInstruction - local.set $isInstructionInMask - local.get $isInstructionInMask - i32.eqz - if - br $for-continue|0 - end - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipArgs - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#__get - end - local.set $iData - local.get $iData - call $assembly/instructions/Instruction#get:isTerminating - local.set $isTerminating - local.get $isTerminating - if - local.get $n - i32.const 1 - i32.add - local.get $skipArgs - i32.add - local.set $newBlockStart - local.get $newBlockStart - local.get $len - i32.lt_s - if - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $newBlockStart - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set - end - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - local.get $n - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.END - i32.or - call $~lib/staticarray/StaticArray#__set - end - end - local.get $n - i32.const 1 - i32.add - local.set $n - br $for-loop|0 - end - end - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - call $assembly/program/BasicBlocks#set:isStartOrEnd - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - ) - (func $assembly/program/Program#constructor (param $this i32) (param $code i32) (param $mask i32) (param $jumpTable i32) (param $basicBlocks i32) (result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 41 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $code - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:code - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:mask - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:jumpTable - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:basicBlocks - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/program/deblob (param $program i32) (result i32) - (local $decoder i32) - (local $jumpTableLength i32) - (local $jumpTableItemLength i32) - (local $codeLength i32) - (local $jumpTableLengthInBytes i32) - (local $rawJumpTable i32) - (local $rawCode i32) - (local $rawMask i32) - (local $mask i32) - (local $jumpTable i32) - (local $basicBlocks i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $program - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=4 - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#varU32 - local.set $jumpTableLength - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#u8 - local.set $jumpTableItemLength - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#varU32 - local.set $codeLength - local.get $jumpTableLength - local.get $jumpTableItemLength - i32.mul - local.set $jumpTableLengthInBytes - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $jumpTableLengthInBytes - call $assembly/codec/Decoder#bytes - local.tee $rawJumpTable - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - call $assembly/codec/Decoder#bytes - local.tee $rawCode - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - i32.const 7 - i32.add - i32.const 8 - i32.div_u - call $assembly/codec/Decoder#bytes - local.tee $rawMask - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $rawMask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $jumpTableItemLength - local.get $rawJumpTable - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/program/JumpTable#constructor - local.tee $jumpTable - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $rawCode - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $mask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - call $assembly/program/BasicBlocks#constructor - local.tee $basicBlocks - i32.store offset=32 - i32.const 0 - local.get $rawCode - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $mask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - local.get $jumpTable - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=36 - local.get $12 - local.get $basicBlocks - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=40 - local.get $12 - call $assembly/program/Program#constructor - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $~lib/string/String.__concat (param $left i32) (param $right i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $left - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $right - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/string/String#concat - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/program/Mask#toString (param $this i32) (result i32) - (local $v i32) - (local $i i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 22944 - local.tee $v - i32.store - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/program/Mask#get:bytesToSkip - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=24 - local.get $3 - call $assembly/program/Mask#get:bytesToSkip - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=20 - local.get $3 - local.get $i - call $~lib/staticarray/StaticArray#__get - i32.const 10 - call $~lib/number/U32#toString - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - i32.const 22976 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $3 - call $~lib/string/String#concat - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $~lib/string/String.__concat - local.tee $v - i32.store - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $v - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 23008 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $~lib/string/String#concat - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/JumpTable#toString (param $this i32) (result i32) - (local $v i32) - (local $i i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 23280 - local.tee $v - i32.store - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/JumpTable#get:jumps - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $~lib/memory/__stack_pointer - local.get $i - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/program/JumpTable#get:jumps - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - local.get $i - call $~lib/staticarray/StaticArray#__get - i32.const 10 - call $~lib/number/U64#toString - local.tee $4 - i32.store offset=24 - i32.const 23360 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 0 - local.get $3 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 23360 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 2 - local.get $4 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 23360 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/string/String.__concat - local.tee $v - i32.store - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $v - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 23008 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/string/String#concat - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/program/BasicBlocks#toString (param $this i32) (result i32) - (local $v i32) - (local $i i32) - (local $t i32) - (local $isStart i32) - (local $isEnd i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 23456 - local.tee $v - i32.store - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 4080 - local.tee $t - i32.store offset=12 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $i - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.START - i32.and - i32.const 0 - i32.gt_s - local.set $isStart - global.get $~lib/memory/__stack_pointer - local.get $t - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $isStart - if (result i32) - i32.const 23504 - else - i32.const 4080 - end - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String.__concat - local.tee $t - i32.store offset=12 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $i - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.END - i32.and - i32.const 0 - i32.gt_s - local.set $isEnd - global.get $~lib/memory/__stack_pointer - local.get $t - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $isEnd - if (result i32) - i32.const 23536 - else - i32.const 4080 - end - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String.__concat - local.tee $t - i32.store offset=12 - local.get $t - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $~lib/string/String#get:length - i32.const 0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $~lib/memory/__stack_pointer - local.get $i - i32.const 10 - call $~lib/number/I32#toString - local.tee $6 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $t - local.tee $7 - i32.store offset=20 - i32.const 23568 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 0 - local.get $6 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 23568 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 2 - local.get $7 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 23568 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String.__concat - local.tee $v - i32.store - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $v - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 23008 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/program.test~anonymous|4 (param $$0 i32) (result i32) - (local $1 i32) - (local $raw i32) - (local $program i32) - (local $assert i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 41 - i32.const 3 - i32.const 39 - i32.const 22144 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program.test/u8arr - local.tee $raw - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $raw - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program/deblob - local.tee $program - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $program - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=32 - local.get $5 - call $assembly/program/Program#get:mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/program/Mask#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 23040 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $program - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=32 - local.get $5 - call $assembly/program/Program#get:jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/program/JumpTable#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 23408 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $program - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=32 - local.get $5 - call $assembly/program/Program#get:basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/program/BasicBlocks#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 23616 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#indexOf (param $this i32) (param $value i32) (param $fromIndex i32) (result i32) - (local $len i32) - (local $4 i32) - (local $5 i32) - (local $ptr i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ - local.set $len - local.get $len - i32.const 0 - i32.eq - if (result i32) - i32.const 1 - else - local.get $fromIndex - local.get $len - i32.ge_s - end - if - i32.const -1 - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $fromIndex - i32.const 0 - i32.lt_s - if - local.get $len - local.get $fromIndex - i32.add - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - local.set $fromIndex - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart - local.set $ptr - loop $while-continue|0 - local.get $fromIndex - local.get $len - i32.lt_s - if - local.get $ptr - local.get $fromIndex - i32.const 2 - i32.shl - i32.add - i32.load - local.get $value - i32.eq - if - local.get $fromIndex - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $fromIndex - i32.const 1 - i32.add - local.set $fromIndex - br $while-continue|0 - end - end - i32.const -1 - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $assembly/program.test/opcode (param $search i32) (result f64) - (local $idx i32) - (local $2 i32) - (local $3 f64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $assembly/instructions-exe/RUN - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $search - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#indexOf - local.set $idx - local.get $idx - i32.const 0 - i32.lt_s - if - i32.const 24080 - i32.const 24192 - i32.const 152 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $idx - f64.convert_i32_s - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value f64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 1888 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 3 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 3 - i32.shl - i32.add - local.get $value - f64.store - i32.const 0 - drop - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/program.test~anonymous|5 (param $$0 i32) (result i32) - (local $1 i32) - (local $code i32) - (local $3 i32) - (local $mask i32) - (local $basicBlocks i32) - (local $assert i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.const 3 - i32.const 39 - i32.const 0 - call $~lib/rt/__newArray - local.tee $1 - i32.store offset=4 - local.get $1 - i32.const 0 - global.get $assembly/instructions/misc/trap - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/program.test/opcode - call $~lib/array/Array#__set - local.get $1 - i32.const 1 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 2 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 3 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 4 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 5 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 6 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 7 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 8 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 9 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 10 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 11 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 12 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 13 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 14 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 15 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 16 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 17 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 18 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 19 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 20 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 21 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 22 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 23 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 24 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 25 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 26 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 27 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 28 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 29 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 30 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 31 - global.get $assembly/instructions/jump/jump_ind - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/program.test/opcode - call $~lib/array/Array#__set - local.get $1 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $assembly/program.test/u8arr - local.tee $code - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 4 - i32.const 3 - i32.const 39 - i32.const 24272 - call $~lib/rt/__newArray - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/program.test/u8arr - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - i32.const 32 - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $code - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $mask - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/program/BasicBlocks#constructor - local.tee $basicBlocks - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=24 - local.get $assert - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $mask - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=36 - local.get $7 - call $assembly/program/Mask#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - i32.const 24336 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=28 - local.get $7 - i32.const 4080 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=32 - local.get $7 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $basicBlocks - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=36 - local.get $7 - call $assembly/program/BasicBlocks#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - i32.const 24608 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=28 - local.get $7 - i32.const 4080 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=32 - local.get $7 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $start:assembly/program.test~anonymous|6 (param $$0 i32) (result i32) - (local $1 i32) - (local $jumpTable i32) - (local $assert i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 10 - i32.const 30 - i32.const 3 - i32.const 39 - i32.const 24880 - call $~lib/rt/__newArray - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/program.test/u8arr - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/program/JumpTable#constructor - local.tee $jumpTable - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $jumpTable - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=24 - local.get $4 - call $assembly/program/JumpTable#toString - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 25152 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - i32.const 4080 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - local.get $4 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/program.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - call $start:assembly/program - global.get $~lib/memory/__stack_pointer - i32.const 7 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 20752 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 21056 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 21088 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 21424 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 21456 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 21872 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - i32.const 21904 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 22048 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - i32.const 22080 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 23920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 5 - i32.const 23952 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 24736 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 6 - i32.const 24768 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 25360 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/program.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/array/Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/array/Array#get:dataStart - local.set $sourceStart - i32.const 0 - i32.eqz - drop - local.get $targetStart - local.get $sourceStart - local.get $sourceLen - i32.const 0 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/liftBytes (param $data i32) (result i32) - (local $p i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $p - i32.store offset=4 - local.get $p - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#set<~lib/array/Array> - local.get $p - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u24 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 3 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 3 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u16 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 2 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.const 15 - i32.and - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u32 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 4 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 3 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 4 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#isExhausted (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#get:offset - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $assembly/codec/Decoder#get:source - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - i32.ge_s - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $assembly/codec/Decoder#finish (param $this i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - i32.const 25696 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - call $assembly/codec/Decoder#get:source - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/codec/Decoder#get:offset - i32.sub - i32.const 10 - call $~lib/number/I32#toString - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/string/String#concat - i32.const 22672 - i32.const 31 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MemoryBuilder#setEmpty (param $this i32) (param $access i32) (param $address i32) (param $len i32) (result i32) - (local $endAddress i32) - (local $currentAddress i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $address - local.get $len - i32.add - local.set $endAddress - local.get $address - local.set $currentAddress - loop $for-loop|0 - local.get $currentAddress - local.get $endAddress - i32.lt_u - if - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $access - local.get $currentAddress - call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress - drop - local.get $currentAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.add - local.set $currentAddress - br $for-loop|0 - end - end - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/spi/StandardProgram#constructor (param $this i32) (param $program i32) (param $memory i32) (param $registers i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 47 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:program - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:memory - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:registers - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:metadata - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/spi/StandardProgram#set:pc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i64.const 0 - call $assembly/spi/StandardProgram#set:gas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/spi/decodeSpi (param $data i32) (param $args i32) (result i32) - (local $argsLength i32) - (local $decoder i32) - (local $roLength i32) - (local $rwLength i32) - (local $heapPages i32) - (local $stackSize i32) - (local $roMem i32) - (local $rwMem i32) - (local $codeLength i32) - (local $code i32) - (local $program i32) - (local $builder i32) - (local $heapStart i32) - (local $heapZerosStart i32) - (local $heapZerosLength i32) - (local $heapZerosEnd i32) - (local $stackLength i32) - (local $stackStart i32) - (local $memory i32) - (local $registers i32) - (local $22 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - local.get $args - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $~lib/typedarray/Uint8Array#get:length - local.set $argsLength - local.get $argsLength - global.get $assembly/spi/DATA_LENGTH - i32.gt_u - if - i32.const 25552 - i32.const 25632 - i32.const 18 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=4 - local.get $decoder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $assembly/codec/Decoder#u24 - local.set $roLength - local.get $decoder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $assembly/codec/Decoder#u24 - local.set $rwLength - local.get $decoder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $assembly/codec/Decoder#u16 - local.set $heapPages - local.get $decoder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $assembly/codec/Decoder#u24 - local.set $stackSize - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - local.get $roLength - call $assembly/codec/Decoder#bytes - local.tee $roMem - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - local.get $rwLength - call $assembly/codec/Decoder#bytes - local.tee $rwMem - i32.store offset=12 - local.get $decoder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $assembly/codec/Decoder#u32 - local.set $codeLength - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - local.get $codeLength - call $assembly/codec/Decoder#bytes - local.tee $code - i32.store offset=16 - local.get $decoder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $assembly/codec/Decoder#finish - global.get $~lib/memory/__stack_pointer - local.get $code - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $assembly/program/deblob - local.tee $program - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store offset=24 - i32.const 2 - global.get $assembly/memory-page/SEGMENT_SIZE - i32.mul - local.get $roLength - call $assembly/spi/alignToSegmentSize - i32.add - local.set $heapStart - local.get $heapStart - local.get $rwLength - call $assembly/spi/alignToPageSize - i32.add - local.set $heapZerosStart - local.get $heapPages - i32.const 65535 - i32.and - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.set $heapZerosLength - local.get $heapZerosStart - local.get $heapZerosLength - i32.add - local.set $heapZerosEnd - local.get $stackSize - call $assembly/spi/alignToPageSize - local.set $stackLength - global.get $assembly/spi/STACK_SEGMENT_END - local.get $stackLength - i32.sub - local.set $stackStart - local.get $roLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - global.get $assembly/memory-page/Access.Read - global.get $assembly/memory-page/SEGMENT_SIZE - local.get $roMem - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store offset=28 - local.get $22 - call $assembly/memory/MemoryBuilder#setData - drop - end - local.get $argsLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - global.get $assembly/memory-page/Access.Read - global.get $assembly/spi/ARGS_SEGMENT_START - local.get $args - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store offset=28 - local.get $22 - call $assembly/memory/MemoryBuilder#setData - drop - end - local.get $rwLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - global.get $assembly/memory-page/Access.Write - local.get $heapStart - local.get $rwMem - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store offset=28 - local.get $22 - call $assembly/memory/MemoryBuilder#setData - drop - end - local.get $heapZerosLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - global.get $assembly/memory-page/Access.Write - local.get $heapZerosStart - local.get $heapZerosLength - call $assembly/memory/MemoryBuilder#setEmpty - drop - end - local.get $stackLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - global.get $assembly/memory-page/Access.Write - local.get $stackStart - local.get $stackLength - call $assembly/memory/MemoryBuilder#setEmpty - drop - end - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - local.get $heapZerosEnd - call $assembly/memory/MemoryBuilder#build - local.tee $memory - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=36 - local.get $registers - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - i32.const 0 - i64.const 4294901760 - call $~lib/staticarray/StaticArray#__set - local.get $registers - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - i32.const 1 - global.get $assembly/spi/STACK_SEGMENT_END - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - local.get $registers - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - i32.const 7 - global.get $assembly/spi/ARGS_SEGMENT_START - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - local.get $registers - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - i32.const 8 - local.get $argsLength - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - i32.const 0 - local.get $program - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - local.get $memory - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store offset=28 - local.get $22 - local.get $registers - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store offset=40 - local.get $22 - call $assembly/spi/StandardProgram#constructor - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - ) - (func $assembly/program/Program#toString (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program/Program#get:code - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#toString - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program/Program#get:mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program/Mask#toString - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program/Program#get:jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program/JumpTable#toString - local.tee $3 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program/Program#get:basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program/BasicBlocks#toString - local.tee $4 - i32.store offset=20 - i32.const 26320 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - local.get $1 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26320 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 3 - local.get $2 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26320 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 5 - local.get $3 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26320 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 7 - local.get $4 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26320 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $"~lib/map/Map#get:size" (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $"~lib/map/Map#get:entriesCount" - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $value i64) - (local $sepLen i32) - (local $estLen i32) - (local $result i32) - (local $offset i32) - (local $value|9 i64) - (local $i i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 4080 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $lastIndex - i32.eqz - if - local.get $dataStart - i64.load - local.set $value - i32.const 0 - drop - i32.const 8 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 10 - call $~lib/util/number/utoa64 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $separator - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - local.set $sepLen - i32.const 20 - local.get $sepLen - i32.add - local.get $lastIndex - i32.mul - i32.const 20 - i32.add - local.set $estLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=4 - i32.const 0 - local.set $offset - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $lastIndex - i32.lt_s - if - local.get $dataStart - local.get $i - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $dataStart - local.get $lastIndex - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $estLen - local.get $offset - i32.gt_s - if - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.const 0 - local.get $offset - call $~lib/string/String#substring - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/staticarray/StaticArray#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 0 - drop - i32.const 1 - drop - local.get $this - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/staticarray/StaticArray#get:length - local.get $separator - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/util/string/joinIntegerArray - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/staticarray/StaticArray#toString (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 10000 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/staticarray/StaticArray#join - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $assembly/spi/StandardProgram#toString (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/spi/StandardProgram#get:program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/program/Program#toString - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/spi/StandardProgram#get:memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Memory#get:pages - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $"~lib/map/Map#get:size" - i32.const 10 - call $~lib/number/I32#toString - local.tee $2 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/spi/StandardProgram#get:registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/staticarray/StaticArray#toString - local.tee $3 - i32.store offset=20 - i32.const 26048 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $1 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26048 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 3 - local.get $2 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26048 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 5 - local.get $3 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26048 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 4080 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/spi.test~anonymous|0 (param $$0 i32) (result i32) - (local $1 i32) - (local $PROGRAM i32) - (local $3 i32) - (local $ARGS i32) - (local $spi i32) - (local $assert i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 0 - i32.const 34 - i32.const 25472 - call $~lib/rt/__newArray - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $assembly/program/liftBytes - local.tee $PROGRAM - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 3 - i32.const 0 - i32.const 34 - i32.const 25520 - call $~lib/rt/__newArray - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $assembly/program/liftBytes - local.tee $ARGS - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $PROGRAM - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $ARGS - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/spi/decodeSpi - local.tee $spi - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=20 - local.get $assert - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $spi - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=32 - local.get $7 - call $assembly/spi/StandardProgram#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - i32.const 26384 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=24 - local.get $7 - i32.const 4080 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=28 - local.get $7 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $start:assembly/spi.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - call $start:assembly/spi - global.get $~lib/memory/__stack_pointer - i32.const 1 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 25392 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 26864 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/spi.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 21616 - i32.const 1888 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array<~lib/string/String>#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array<~lib/string/String>#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array<~lib/string/String>#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<~lib/string/String>#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 21616 - i32.const 1888 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/test-run/printSummary (param $msg i32) (param $okay i32) (param $total i32) - (local $ico i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $okay - local.get $total - i32.eq - if (result i32) - i32.const 27216 - else - i32.const 27248 - end - local.tee $ico - i32.store - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $4 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $okay - i32.const 10 - call $~lib/number/U32#toString - local.tee $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $total - i32.const 10 - call $~lib/number/U32#toString - local.tee $6 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $ico - local.tee $7 - i32.store offset=20 - i32.const 27344 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 0 - local.get $4 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27344 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 2 - local.get $5 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27344 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 4 - local.get $6 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27344 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 6 - local.get $7 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27344 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/test-run/run (param $tests i32) (param $file i32) (result i64) - (local $ok i32) - (local $i i32) - (local $res i32) - (local $5 i32) - (local $j i32) - (local $7 i32) - (local $8 i32) - (local $9 i64) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - i32.const 0 - local.set $ok - i32.const 26928 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $file - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/console/console.log - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/array/Array#get:length - i32.lt_s - if - i32.const 26960 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - local.get $i - call $~lib/array/Array#__get - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $assembly/test/Test#get:name - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - global.set $~argumentsLength - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - local.get $i - call $~lib/array/Array#__get - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/test/Test#get:ptr - i32.load - call_indirect (type $0) - local.tee $res - i32.store offset=20 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/test/Assert#get:isOkay - if - global.get $~lib/memory/__stack_pointer - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - local.get $i - call $~lib/array/Array#__get - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/test/Test#get:name - local.tee $5 - i32.store offset=24 - i32.const 27056 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 1 - local.get $5 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27056 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/console/console.log - local.get $ok - i32.const 1 - i32.add - local.set $ok - else - i32.const 0 - local.set $j - loop $for-loop|1 - local.get $j - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/test/Assert#get:errors - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/array/Array<~lib/string/String>#get:length - i32.lt_s - if - i32.const 27088 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $assembly/test/Assert#get:errors - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - local.get $j - call $~lib/array/Array<~lib/string/String>#__get - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/console/console.log - local.get $j - i32.const 1 - i32.add - local.set $j - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - local.get $i - call $~lib/array/Array#__get - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/test/Test#get:name - local.tee $7 - i32.store offset=28 - i32.const 27152 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 1 - local.get $7 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27152 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/console/console.log - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 27184 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $file - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $ok - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $~lib/array/Array#get:length - call $assembly/test-run/printSummary - local.get $ok - i64.extend_i32_s - i64.const 32 - i64.shl - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/array/Array#get:length - i64.extend_i32_s - i64.add - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $assembly/test-run/runAllTests - (local $a i64) - (local $okay i32) - (local $total i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i64.const 0 - local.set $a - local.get $a - global.get $assembly/instructions/bit.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 26896 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/instructions/branch.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27392 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/instructions/logic.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27440 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/instructions/math.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27488 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/memory.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27536 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/program.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27584 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/instructions/rot.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27632 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/spi.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27664 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - i64.const 32 - i64.shr_u - i32.wrap_i64 - local.set $okay - local.get $a - i32.wrap_i64 - local.set $total - i32.const 27696 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $okay - local.get $total - call $assembly/test-run/printSummary - local.get $okay - local.get $total - i32.ne - if - i32.const 27744 - i32.const 27808 - i32.const 28 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#__visit" (param $this i32) (param $cookie i32) - (local $entries i32) - (local $cur i32) - (local $end i32) - (local $entry i32) - (local $val i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:buckets" - local.get $cookie - call $~lib/rt/itcms/__visit - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:entries" - local.set $entries - i32.const 1 - drop - local.get $entries - local.set $cur - local.get $cur - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.6" - end - i32.mul - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - drop - i32.const 1 - drop - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $val - i32.const 0 - drop - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.7" - end - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $entries - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28u8%29=>u8>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28u8%29=>u8>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/object/Object#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 3 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1408 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 3 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 13 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/arraybuffer/ArrayBuffer#constructor (param $this i32) (param $length i32) (result i32) - (local $buffer i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.gt_u - if - i32.const 1296 - i32.const 1344 - i32.const 52 - i32.const 43 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $buffer - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/rt/__newArray (param $length i32) (param $alignLog2 i32) (param $id i32) (param $data i32) (result i32) - (local $bufferSize i32) - (local $buffer i32) - (local $array i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - local.get $alignLog2 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - local.get $data - call $~lib/rt/__newBuffer - local.tee $buffer - i32.store - i32.const 16 - local.get $id - call $~lib/rt/itcms/__new - local.set $array - local.get $array - local.get $buffer - i32.store - local.get $array - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - local.get $array - local.get $buffer - i32.store offset=4 - local.get $array - local.get $bufferSize - i32.store offset=8 - local.get $array - local.get $length - i32.store offset=12 - local.get $array - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $~lib/util/number/itoa32 (param $value i32) (param $radix i32) (result i32) - (local $sign i32) - (local $out i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|8 i32) - (local $buffer|9 i32) - (local $num|10 i32) - (local $offset|11 i32) - (local $val32 i32) - (local $decimals|13 i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 2304 - i32.const 2432 - i32.const 373 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i32.eqz - if - i32.const 2496 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $value - i32.const 31 - i32.shr_u - i32.const 1 - i32.shl - local.set $sign - local.get $sign - if - i32.const 0 - local.get $value - i32.sub - local.set $value - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer - local.get $value - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 31 - local.get $value - i32.clz - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|8 - global.get $~lib/memory/__stack_pointer - local.get $decimals|8 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|9 - local.get $value - local.set $num|10 - local.get $decimals|8 - local.set $offset|11 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|9 - local.get $num|10 - i64.extend_i32_u - local.get $offset|11 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.set $val32 - local.get $val32 - i64.extend_i32_u - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|13 - global.get $~lib/memory/__stack_pointer - local.get $decimals|13 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.get $val32 - i64.extend_i32_u - local.get $decimals|13 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $sign - if - local.get $out - i32.const 45 - i32.store16 - end - local.get $out - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - ) - (func $~lib/util/number/utoa64 (param $value i64) (param $radix i32) (result i32) - (local $out i32) - (local $val32 i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|8 i32) - (local $buffer|9 i32) - (local $num|10 i64) - (local $offset|11 i32) - (local $decimals|12 i32) - (local $buffer|13 i32) - (local $num|14 i64) - (local $offset|15 i32) - (local $decimals|16 i32) - (local $17 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 2304 - i32.const 2432 - i32.const 401 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i64.const 0 - i64.ne - i32.eqz - if - i32.const 2496 - local.set $17 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $17 - return - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - call $~lib/util/number/decimalCount64High - local.set $decimals|8 - global.get $~lib/memory/__stack_pointer - local.get $decimals|8 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|9 - local.get $value - local.set $num|10 - local.get $decimals|8 - local.set $offset|11 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|9 - local.get $num|10 - local.get $offset|11 - call $~lib/util/number/utoa64_dec_lut - end - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 63 - local.get $value - i64.clz - i32.wrap_i64 - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|12 - global.get $~lib/memory/__stack_pointer - local.get $decimals|12 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|13 - local.get $value - local.set $num|14 - local.get $decimals|12 - local.set $offset|15 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|13 - local.get $num|14 - local.get $offset|15 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|16 - global.get $~lib/memory/__stack_pointer - local.get $decimals|16 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $value - local.get $decimals|16 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $out - local.set $17 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $17 - return - ) - (func $~lib/util/number/itoa64 (param $value i64) (param $radix i32) (result i32) - (local $sign i32) - (local $out i32) - (local $val32 i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|9 i32) - (local $buffer|10 i32) - (local $num|11 i64) - (local $offset|12 i32) - (local $decimals|13 i32) - (local $buffer|14 i32) - (local $num|15 i64) - (local $offset|16 i32) - (local $decimals|17 i32) - (local $18 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 2304 - i32.const 2432 - i32.const 431 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i64.const 0 - i64.ne - i32.eqz - if - i32.const 2496 - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - end - local.get $value - i64.const 63 - i64.shr_u - i32.wrap_i64 - i32.const 1 - i32.shl - local.set $sign - local.get $sign - if - i64.const 0 - local.get $value - i64.sub - local.set $value - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - call $~lib/util/number/decimalCount64High - local.set $decimals|9 - global.get $~lib/memory/__stack_pointer - local.get $decimals|9 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|10 - local.get $value - local.set $num|11 - local.get $decimals|9 - local.set $offset|12 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|10 - local.get $num|11 - local.get $offset|12 - call $~lib/util/number/utoa64_dec_lut - end - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 63 - local.get $value - i64.clz - i32.wrap_i64 - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|13 - global.get $~lib/memory/__stack_pointer - local.get $decimals|13 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|14 - local.get $value - local.set $num|15 - local.get $decimals|13 - local.set $offset|16 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|14 - local.get $num|15 - local.get $offset|16 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|17 - global.get $~lib/memory/__stack_pointer - local.get $decimals|17 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.get $value - local.get $decimals|17 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $sign - if - local.get $out - i32.const 45 - i32.store16 - end - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - ) - (func $~lib/util/number/utoa32 (param $value i32) (param $radix i32) (result i32) - (local $out i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|7 i32) - (local $buffer|8 i32) - (local $num|9 i32) - (local $offset|10 i32) - (local $decimals|11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 2304 - i32.const 2432 - i32.const 350 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i32.eqz - if - i32.const 2496 - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer - local.get $value - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 31 - local.get $value - i32.clz - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|7 - global.get $~lib/memory/__stack_pointer - local.get $decimals|7 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|8 - local.get $value - local.set $num|9 - local.get $decimals|7 - local.set $offset|10 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|8 - local.get $num|9 - i64.extend_i32_u - local.get $offset|10 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - i64.extend_i32_u - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|11 - global.get $~lib/memory/__stack_pointer - local.get $decimals|11 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $value - i64.extend_i32_u - local.get $decimals|11 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $out - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 0 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1408 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 0 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 29 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1408 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 2 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 38 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1408 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 2 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 44 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) -) From da9fde71408bd08d1b03b71f3488e4adb44cbf12 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Mon, 13 Oct 2025 18:57:18 +0200 Subject: [PATCH 04/21] update build --- build/debug.d.ts | 192 +- build/debug.js | 213 +- build/debug.wasm | Bin 186138 -> 197849 bytes build/debug.wasm.map | 2 +- build/debug.wat | 37282 +++++++++++++++++++++------------------ build/release.d.ts | 192 +- build/release.js | 213 +- build/release.wasm | Bin 93361 -> 96928 bytes build/release.wasm.map | 2 +- build/release.wat | 25678 ++++++++++++++------------- 10 files changed, 33967 insertions(+), 29807 deletions(-) diff --git a/build/debug.d.ts b/build/debug.d.ts index 97c330c..08a7a0a 100644 --- a/build/debug.d.ts +++ b/build/debug.d.ts @@ -1,45 +1,7 @@ /** Exported memory */ export declare const memory: WebAssembly.Memory; -/** assembly/index/InputKind */ -export declare enum InputKind { - /** @type `i32` */ - Generic, - /** @type `i32` */ - SPI, -} -/** assembly/index/HasMetadata */ -export declare enum HasMetadata { - /** @type `i32` */ - Yes, - /** @type `i32` */ - No, -} /** - * assembly/index/disassemble - * @param input `~lib/array/Array` - * @param kind `i32` - * @param withMetadata `i32` - * @returns `~lib/string/String` - */ -export declare function disassemble(input: Array, kind: number, withMetadata: number): string; -/** - * assembly/index/runProgram - * @param input `~lib/array/Array` - * @param registers `~lib/array/Array` - * @param kind `i32` - * @returns `assembly/api-generic/VmOutput` - */ -export declare function runProgram(input: Array, registers: Array, kind: number): __Record44; -/** - * assembly/api-generic/runVm - * @param input `assembly/api-generic/VmInput` - * @param logs `bool` - * @param useSbrkGas `bool` - * @returns `assembly/api-generic/VmOutput` - */ -export declare function runVm(input: __Record47, logs?: boolean, useSbrkGas?: boolean): __Record44; -/** - * assembly/api-generic/getAssembly + * assembly/api-internal/getAssembly * @param p `assembly/program/Program` * @returns `~lib/string/String` */ @@ -51,107 +13,160 @@ export declare function getAssembly(p: __Internref30): string; */ export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array; /** - * assembly/api/resetGeneric + * assembly/api-debugger/resetJAM + * @param program `~lib/array/Array` + * @param pc `f64` + * @param initialGas `i64` + * @param args `~lib/array/Array` + * @param hasMetadata `bool` + */ +export declare function resetJAM(program: Array, pc: number, initialGas: bigint, args: Array, hasMetadata?: boolean): void; +/** + * assembly/api-debugger/resetGeneric * @param program `~lib/array/Array` * @param flatRegisters `~lib/array/Array` * @param initialGas `i64` + * @param hasMetadata `bool` */ -export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint): void; +export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint, hasMetadata?: boolean): void; /** - * assembly/api/resetGenericWithMemory + * assembly/api-debugger/resetGenericWithMemory * @param program `~lib/array/Array` * @param flatRegisters `~lib/array/Array` * @param pageMap `~lib/typedarray/Uint8Array` * @param chunks `~lib/typedarray/Uint8Array` * @param initialGas `i64` + * @param hasMetadata `bool` */ -export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint): void; +export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint, hasMetadata?: boolean): void; /** - * assembly/api/nextStep + * assembly/api-debugger/nextStep * @returns `bool` */ export declare function nextStep(): boolean; /** - * assembly/api/nSteps + * assembly/api-debugger/nSteps * @param steps `u32` * @returns `bool` */ export declare function nSteps(steps: number): boolean; /** - * assembly/api/getProgramCounter + * assembly/api-debugger/getProgramCounter * @returns `u32` */ export declare function getProgramCounter(): number; /** - * assembly/api/setNextProgramCounter + * assembly/api-debugger/setNextProgramCounter * @param pc `u32` */ export declare function setNextProgramCounter(pc: number): void; /** - * assembly/api/getStatus + * assembly/api-debugger/getStatus * @returns `u8` */ export declare function getStatus(): number; /** - * assembly/api/getExitArg + * assembly/api-debugger/getExitArg * @returns `u32` */ export declare function getExitArg(): number; /** - * assembly/api/getGasLeft + * assembly/api-debugger/getGasLeft * @returns `i64` */ export declare function getGasLeft(): bigint; /** - * assembly/api/setGasLeft + * assembly/api-debugger/setGasLeft * @param gas `i64` */ export declare function setGasLeft(gas: bigint): void; /** - * assembly/api/getRegisters + * assembly/api-debugger/getRegisters * @returns `~lib/typedarray/Uint8Array` */ export declare function getRegisters(): Uint8Array; /** - * assembly/api/setRegisters + * assembly/api-debugger/setRegisters * @param flatRegisters `~lib/array/Array` */ export declare function setRegisters(flatRegisters: Array): void; /** - * assembly/api/getPageDump + * assembly/api-debugger/getPageDump * @param index `u32` * @returns `~lib/typedarray/Uint8Array` */ export declare function getPageDump(index: number): Uint8Array; /** - * assembly/api/setMemory + * assembly/api-debugger/setMemory * @param address `u32` * @param data `~lib/typedarray/Uint8Array` */ export declare function setMemory(address: number, data: Uint8Array): void; -/** assembly/api-generic/InitialChunk */ -declare interface __Record45 { - /** @type `u32` */ - address: number | TOmittable; - /** @type `~lib/array/Array` */ - data: Array; +/** assembly/api-utils/InputKind */ +export declare enum InputKind { + /** @type `i32` */ + Generic, + /** @type `i32` */ + SPI, } -/** assembly/api-generic/VmOutput */ -declare interface __Record44 { +/** assembly/api-utils/HasMetadata */ +export declare enum HasMetadata { /** @type `i32` */ - status: number | TOmittable; - /** @type `~lib/array/Array` */ - registers: Array; + Yes, + /** @type `i32` */ + No, +} +/** + * assembly/api-utils/getGasCosts + * @param input `~lib/array/Array` + * @param kind `i32` + * @param withMetadata `i32` + * @returns `~lib/array/Array` + */ +export declare function getGasCosts(input: Array, kind: number, withMetadata: number): Array<__Record54>; +/** + * assembly/api-utils/disassemble + * @param input `~lib/array/Array` + * @param kind `i32` + * @param withMetadata `i32` + * @returns `~lib/string/String` + */ +export declare function disassemble(input: Array, kind: number, withMetadata: number): string; +/** + * assembly/api-utils/prepareProgram + * @param kind `i32` + * @param hasMetadata `i32` + * @param program `~lib/array/Array` + * @param initialRegisters `~lib/array/Array` + * @param initialPageMap `~lib/array/Array` + * @param initialMemory `~lib/array/Array` + * @param args `~lib/array/Array` + * @returns `assembly/spi/StandardProgram` + */ +export declare function prepareProgram(kind: number, hasMetadata: number, program: Array, initialRegisters: Array, initialPageMap: Array<__Record48>, initialMemory: Array<__Record50>, args: Array): __Internref44; +/** + * assembly/api-utils/runProgram + * @param program `assembly/spi/StandardProgram` + * @param initialGas `i64` + * @param programCounter `u32` + * @param logs `bool` + * @param useSbrkGas `bool` + * @returns `assembly/api-internal/VmOutput` + */ +export declare function runProgram(program: __Internref44, initialGas?: bigint, programCounter?: number, logs?: boolean, useSbrkGas?: boolean): __Record59; +/** assembly/program/Program */ +declare class __Internref30 extends Number { + private __nominal30: symbol; + private __nominal0: symbol; +} +/** assembly/gas-costs/BlockGasCost */ +declare interface __Record54 { /** @type `u32` */ pc: number | TOmittable; - /** @type `~lib/array/Array` */ - memory: Array<__Record45>; - /** @type `i64` */ + /** @type `u64` */ gas: bigint | TOmittable; - /** @type `u32` */ - exitCode: number | TOmittable; } -/** assembly/api-generic/InitialPage */ +/** assembly/api-internal/InitialPage */ declare interface __Record48 { /** @type `u32` */ address: number | TOmittable; @@ -160,23 +175,30 @@ declare interface __Record48 { /** @type `i32` */ access: number | TOmittable; } -/** assembly/api-generic/VmInput */ -declare interface __Record47 { +/** assembly/api-internal/InitialChunk */ +declare interface __Record50 { + /** @type `u32` */ + address: number | TOmittable; + /** @type `~lib/array/Array` */ + data: Array; +} +/** assembly/spi/StandardProgram */ +declare class __Internref44 extends Number { + private __nominal44: symbol; + private __nominal0: symbol; +} +/** assembly/api-internal/VmOutput */ +declare interface __Record59 { + /** @type `i32` */ + status: number | TOmittable; /** @type `~lib/array/Array` */ registers: Array; /** @type `u32` */ pc: number | TOmittable; + /** @type `~lib/array/Array` */ + memory: Array<__Record50>; /** @type `i64` */ gas: bigint | TOmittable; - /** @type `~lib/array/Array` */ - program: Array; - /** @type `~lib/array/Array` */ - pageMap: Array<__Record48>; - /** @type `~lib/array/Array` */ - memory: Array<__Record45>; -} -/** assembly/program/Program */ -declare class __Internref30 extends Number { - private __nominal30: symbol; - private __nominal0: symbol; + /** @type `u32` */ + exitCode: number | TOmittable; } diff --git a/build/debug.js b/build/debug.js index 1fc85df..383032a 100644 --- a/build/debug.js +++ b/build/debug.js @@ -22,43 +22,8 @@ async function instantiate(module, imports = {}) { const { exports } = await WebAssembly.instantiate(module, adaptedImports); const memory = exports.memory || imports.env.memory; const adaptedExports = Object.setPrototypeOf({ - InputKind: (values => ( - // assembly/index/InputKind - values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", - values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", - values - ))({}), - HasMetadata: (values => ( - // assembly/index/HasMetadata - values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", - values[values.No = exports["HasMetadata.No"].valueOf()] = "No", - values - ))({}), - disassemble(input, kind, withMetadata) { - // assembly/index/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String - input = __lowerArray(__setU8, 27, 0, input) || __notnull(); - return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); - }, - runProgram(input, registers, kind) { - // assembly/index/runProgram(~lib/array/Array, ~lib/array/Array, i32) => assembly/api-generic/VmOutput - input = __retain(__lowerArray(__setU8, 27, 0, input) || __notnull()); - registers = __lowerArray(__setU64, 43, 3, registers) || __notnull(); - try { - return __liftRecord44(exports.runProgram(input, registers, kind) >>> 0); - } finally { - __release(input); - } - }, - runVm(input, logs, useSbrkGas) { - // assembly/api-generic/runVm(assembly/api-generic/VmInput, bool?, bool?) => assembly/api-generic/VmOutput - input = __lowerRecord47(input) || __notnull(); - logs = logs ? 1 : 0; - useSbrkGas = useSbrkGas ? 1 : 0; - exports.__setArgumentsLength(arguments.length); - return __liftRecord44(exports.runVm(input, logs, useSbrkGas) >>> 0); - }, getAssembly(p) { - // assembly/api-generic/getAssembly(assembly/program/Program) => ~lib/string/String + // assembly/api-internal/getAssembly(assembly/program/Program) => ~lib/string/String p = __lowerInternref(p) || __notnull(); return __liftString(exports.getAssembly(p) >>> 0); }, @@ -67,26 +32,43 @@ async function instantiate(module, imports = {}) { bytecode = __lowerTypedArray(Uint8Array, 5, 0, bytecode) || __notnull(); return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0); }, - resetGeneric(program, flatRegisters, initialGas) { - // assembly/api/resetGeneric(~lib/array/Array, ~lib/array/Array, i64) => void + resetJAM(program, pc, initialGas, args, hasMetadata) { + // assembly/api-debugger/resetJAM(~lib/array/Array, f64, i64, ~lib/array/Array, bool?) => void + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + initialGas = initialGas || 0n; + args = __lowerArray(__setU8, 27, 0, args) || __notnull(); + hasMetadata = hasMetadata ? 1 : 0; + try { + exports.__setArgumentsLength(arguments.length); + exports.resetJAM(program, pc, initialGas, args, hasMetadata); + } finally { + __release(program); + } + }, + resetGeneric(program, flatRegisters, initialGas, hasMetadata) { + // assembly/api-debugger/resetGeneric(~lib/array/Array, ~lib/array/Array, i64, bool?) => void program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); initialGas = initialGas || 0n; + hasMetadata = hasMetadata ? 1 : 0; try { - exports.resetGeneric(program, flatRegisters, initialGas); + exports.__setArgumentsLength(arguments.length); + exports.resetGeneric(program, flatRegisters, initialGas, hasMetadata); } finally { __release(program); } }, - resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas) { - // assembly/api/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64) => void + resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata) { + // assembly/api-debugger/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64, bool?) => void program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); flatRegisters = __retain(__lowerArray(__setU8, 27, 0, flatRegisters) || __notnull()); pageMap = __retain(__lowerTypedArray(Uint8Array, 5, 0, pageMap) || __notnull()); chunks = __lowerTypedArray(Uint8Array, 5, 0, chunks) || __notnull(); initialGas = initialGas || 0n; + hasMetadata = hasMetadata ? 1 : 0; try { - exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas); + exports.__setArgumentsLength(arguments.length); + exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata); } finally { __release(program); __release(flatRegisters); @@ -94,69 +76,103 @@ async function instantiate(module, imports = {}) { } }, nextStep() { - // assembly/api/nextStep() => bool + // assembly/api-debugger/nextStep() => bool return exports.nextStep() != 0; }, nSteps(steps) { - // assembly/api/nSteps(u32) => bool + // assembly/api-debugger/nSteps(u32) => bool return exports.nSteps(steps) != 0; }, getProgramCounter() { - // assembly/api/getProgramCounter() => u32 + // assembly/api-debugger/getProgramCounter() => u32 return exports.getProgramCounter() >>> 0; }, getExitArg() { - // assembly/api/getExitArg() => u32 + // assembly/api-debugger/getExitArg() => u32 return exports.getExitArg() >>> 0; }, setGasLeft(gas) { - // assembly/api/setGasLeft(i64) => void + // assembly/api-debugger/setGasLeft(i64) => void gas = gas || 0n; exports.setGasLeft(gas); }, getRegisters() { - // assembly/api/getRegisters() => ~lib/typedarray/Uint8Array + // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); }, setRegisters(flatRegisters) { - // assembly/api/setRegisters(~lib/array/Array) => void + // assembly/api-debugger/setRegisters(~lib/array/Array) => void flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); exports.setRegisters(flatRegisters); }, getPageDump(index) { - // assembly/api/getPageDump(u32) => ~lib/typedarray/Uint8Array + // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); }, setMemory(address, data) { - // assembly/api/setMemory(u32, ~lib/typedarray/Uint8Array) => void + // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); exports.setMemory(address, data); }, + InputKind: (values => ( + // assembly/api-utils/InputKind + values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", + values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", + values + ))({}), + HasMetadata: (values => ( + // assembly/api-utils/HasMetadata + values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", + values[values.No = exports["HasMetadata.No"].valueOf()] = "No", + values + ))({}), + getGasCosts(input, kind, withMetadata) { + // assembly/api-utils/getGasCosts(~lib/array/Array, i32, i32) => ~lib/array/Array + input = __lowerArray(__setU8, 27, 0, input) || __notnull(); + return __liftArray(pointer => __liftRecord54(__getU32(pointer)), 2, exports.getGasCosts(input, kind, withMetadata) >>> 0); + }, + disassemble(input, kind, withMetadata) { + // assembly/api-utils/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String + input = __lowerArray(__setU8, 27, 0, input) || __notnull(); + return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); + }, + prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) { + // assembly/api-utils/prepareProgram(i32, i32, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array) => assembly/spi/StandardProgram + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + initialRegisters = __retain(__lowerArray(__setU64, 56, 3, initialRegisters) || __notnull()); + initialPageMap = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, initialPageMap) || __notnull()); + initialMemory = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord50(value) || __notnull()); }, 51, 2, initialMemory) || __notnull()); + args = __lowerArray(__setU8, 27, 0, args) || __notnull(); + try { + return __liftInternref(exports.prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) >>> 0); + } finally { + __release(program); + __release(initialRegisters); + __release(initialPageMap); + __release(initialMemory); + } + }, + runProgram(program, initialGas, programCounter, logs, useSbrkGas) { + // assembly/api-utils/runProgram(assembly/spi/StandardProgram, i64?, u32?, bool?, bool?) => assembly/api-internal/VmOutput + program = __lowerInternref(program) || __notnull(); + initialGas = initialGas || 0n; + logs = logs ? 1 : 0; + useSbrkGas = useSbrkGas ? 1 : 0; + exports.__setArgumentsLength(arguments.length); + return __liftRecord59(exports.runProgram(program, initialGas, programCounter, logs, useSbrkGas) >>> 0); + }, }, exports); - function __liftRecord45(pointer) { - // assembly/api-generic/InitialChunk + function __liftRecord54(pointer) { + // assembly/gas-costs/BlockGasCost // Hint: Opt-out from lifting as a record by providing an empty constructor if (!pointer) return null; return { - address: __getU32(pointer + 0), - data: __liftArray(__getU8, 0, __getU32(pointer + 4)), - }; - } - function __liftRecord44(pointer) { - // assembly/api-generic/VmOutput - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - status: __getI32(pointer + 0), - registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), - pc: __getU32(pointer + 8), - memory: __liftArray(pointer => __liftRecord45(__getU32(pointer)), 2, __getU32(pointer + 12)), - gas: __getI64(pointer + 16), - exitCode: __getU32(pointer + 24), + pc: __getU32(pointer + 0), + gas: __getU64(pointer + 8), }; } function __lowerRecord48(value) { - // assembly/api-generic/InitialPage + // assembly/api-internal/InitialPage // Hint: Opt-out from lowering as a record by providing an empty constructor if (value == null) return 0; const pointer = exports.__pin(exports.__new(12, 48)); @@ -166,29 +182,37 @@ async function instantiate(module, imports = {}) { exports.__unpin(pointer); return pointer; } - function __lowerRecord45(value) { - // assembly/api-generic/InitialChunk + function __lowerRecord50(value) { + // assembly/api-internal/InitialChunk // Hint: Opt-out from lowering as a record by providing an empty constructor if (value == null) return 0; - const pointer = exports.__pin(exports.__new(8, 45)); + const pointer = exports.__pin(exports.__new(8, 50)); __setU32(pointer + 0, value.address); __setU32(pointer + 4, __lowerArray(__setU8, 27, 0, value.data) || __notnull()); exports.__unpin(pointer); return pointer; } - function __lowerRecord47(value) { - // assembly/api-generic/VmInput - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(28, 47)); - __setU32(pointer + 0, __lowerArray(__setU64, 43, 3, value.registers) || __notnull()); - __setU32(pointer + 4, value.pc); - __setU64(pointer + 8, value.gas || 0n); - __setU32(pointer + 16, __lowerArray(__setU8, 27, 0, value.program) || __notnull()); - __setU32(pointer + 20, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, value.pageMap) || __notnull()); - __setU32(pointer + 24, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord45(value) || __notnull()); }, 46, 2, value.memory) || __notnull()); - exports.__unpin(pointer); - return pointer; + function __liftRecord50(pointer) { + // assembly/api-internal/InitialChunk + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + address: __getU32(pointer + 0), + data: __liftArray(__getU8, 0, __getU32(pointer + 4)), + }; + } + function __liftRecord59(pointer) { + // assembly/api-internal/VmOutput + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + status: __getI32(pointer + 0), + registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), + pc: __getU32(pointer + 8), + memory: __liftArray(pointer => __liftRecord50(__getU32(pointer)), 2, __getU32(pointer + 12)), + gas: __getI64(pointer + 16), + exitCode: __getU32(pointer + 24), + }; } function __liftString(pointer) { if (!pointer) return null; @@ -247,6 +271,13 @@ async function instantiate(module, imports = {}) { return header; } class Internref extends Number {} + const registry = new FinalizationRegistry(__release); + function __liftInternref(pointer) { + if (!pointer) return null; + const sentinel = new Internref(__retain(pointer)); + registry.register(sentinel, pointer); + return sentinel; + } function __lowerInternref(value) { if (value == null) return 0; if (value instanceof Internref) return value.valueOf(); @@ -341,13 +372,9 @@ async function instantiate(module, imports = {}) { } export const { memory, - InputKind, - HasMetadata, - disassemble, - runProgram, - runVm, getAssembly, wrapAsProgram, + resetJAM, resetGeneric, resetGenericWithMemory, nextStep, @@ -362,6 +389,12 @@ export const { setRegisters, getPageDump, setMemory, + InputKind, + HasMetadata, + getGasCosts, + disassemble, + prepareProgram, + runProgram, } = await (async url => instantiate( await (async () => { const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); diff --git a/build/debug.wasm b/build/debug.wasm index 3e089c857ddf44378c128c5cd641ae7fb6f281ee..cd8496653757ac877fcb9302e2d60e02a701027c 100644 GIT binary patch literal 197849 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 AUIBAGLDSqcDG4NI>;5d${6yY-s^sRr#$VKL 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 E0dMW)pa1{> literal 186138 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 aTef8Wlxa;psjlI^X{(a?!D)lZq5lJAL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/0a78010a7801?v=0.6.4 **/\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT = 12;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/24ee0024ee00?v=0.6.4 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const pageIdx = u32(currentAddress >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n const relAddress = currentAddress % PAGE_SIZE;\n const page = this.pages.get(pageIdx);\n const spaceInPage = PAGE_SIZE - relAddress;\n\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** https://graypaper.fluffylabs.dev/#/9a08063/2cc5022cc502?v=0.6.6 */\nexport function decodeSpi(data: Uint8Array): Program {\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const _heapPages = decoder.u16();\n const _stackSize = decoder.u24();\n\n const _roMem = decoder.bytes(roLength);\n const _rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n return deblob(code);\n}\n\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { RUN } from \"./instructions-exe\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, JumpTable, Program, ProgramCounter, decodeArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { InitialChunk, InitialPage, buildMemory } from \"./api-generic\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { VmInput, VmOutput, getAssembly, runVm } from \"./api-generic\";\nimport { deblob, decodeSpi, extractCodeAndMetadata, liftBytes } from \"./program\";\n\nexport * from \"./api\";\nexport { runVm, getAssembly } from \"./api-generic\";\nexport { wrapAsProgram } from \"./program-build\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n let program = liftBytes(input);\n let output = \"\";\n\n if (withMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(program);\n program = data.code;\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += data.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n if (kind === InputKind.Generic) {\n const p = deblob(program);\n return output + getAssembly(p);\n }\n\n if (kind === InputKind.SPI) {\n const p = decodeSpi(program);\n return output + getAssembly(p);\n }\n\n return `Unknown kind: ${kind}`;\n}\n\nexport function runProgram(input: u8[], registers: u64[], kind: InputKind): VmOutput {\n if (kind === InputKind.Generic) {\n const vmInput = new VmInput();\n vmInput.registers = registers;\n vmInput.gas = 10_000;\n vmInput.program = input;\n\n const output = runVm(vmInput, true);\n console.log(`Finished with status: ${output.status}`);\n return output;\n }\n\n if (kind === InputKind.SPI) {\n throw new Error(\"SPI running not supported yet\");\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { Program, deblob, decodeArguments, liftBytes, resolveArguments } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n registers: u64[] = new Array(NO_OF_REGISTERS).fill(0);\n pc: u32 = 0;\n gas: i64 = 0;\n program: u8[] = [];\n pageMap: InitialPage[] = [];\n memory: InitialChunk[] = [];\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const p = deblob(liftBytes(input.program));\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < registers.length; r++) {\n registers[r] = input.registers[r];\n }\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, input.pageMap, input.memory);\n\n const int = new Interpreter(p, registers, memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = p.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n return this.gas < 0;\n }\n}\n","import { Arguments, REQUIRED_BYTES, nibbles } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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+C,E,YAAA,GErElB,E,eFqEP,G,YAAZ,IACV,GAGE,EAAJ,E,gBAA8B,E,YAAA,GEoCC,E,eFpCT,G,YAAZ,IACN,EAAJ,E,gBAA+B,E,YAAA,G,YAAA,GErDA,E,eFqDT,G,YAAZ,IACN,EAAJ,E,gBAAkC,E,YAAA,GE3EH,E,eF2ET,G,YAAZ,IACN,EAAJ,E,gBAAqC,E,YAAA,G,YAAmB,I,YAAnB,G,YAAf,G,YAAZ,IACN,EAAJ,E,gBAAqC,E,YAAA,G,YAAkB,I,YAAlB,G,YAA0D,I,YAA1D,G,YAAf,G,YAAZ,IACN,EAAJ,E,AACsB,E,YAAA,G,AAAa,E,YAAA,G,YAAA,G,YAAJ,GAAT,G,AAAwC,E,YAAA,G,YAAA,G,YAAiB,E,YAAA,GAAjB,IAA2B,GAAvF,EACc,E,AAAmB,E,YAAJ,G,IAAf,GAAyC,G,AAAsB,E,YAAa,EAAb,IAA7E,E,AACkB,E,YAAA,G,YAAA,G,YAA4C,E,YAAA,GAA5C,GAAlB,E,GACgC,EAAnB,G,KACD,A,GAAiB,E,QAAS,EEhBV,E,6HFgB5B,G,GAC8B,K,AAAY,E,YAAA,G,YAAA,G,YAA0B,E,YAAA,GAAS,EAAT,C,MAA1B,G,YAAuC,E,AAAW,E,YAAA,G,YAA/E,G,KACT,EAAS,EAAT,CAAJ,E,AACc,A,GAChB,E,YAAA,GElE+B,E,WFkEpB,E,YAAA,G,YAAA,EEsBoB,E,WFtBO,E,YAAJ,GAAqB,EAArB,G,QAClC,E,YAAA,GEnE+B,E,WFmEpB,E,YAAA,G,YAAA,EEqBoB,E,WFrBO,E,YAAJ,GAAqB,EAArB,G,QAClC,E,YAAA,GEpE+B,E,WFoEpB,E,YAAA,G,YAAA,EEoBoB,E,WFpBO,E,YAAJ,GAAqB,EAArB,G,QAClC,E,YAAA,GErE+B,E,WFqEpB,E,YAAA,G,YAAA,EEmBoB,E,WFnBO,E,YAAJ,GAAqB,EAArB,G,wdAJ9B,K,AAQG,E,YAAA,GAAP,E,UAGa,G,KACf,E,YAAgB,E,YAAA,GAAhB,G,AACA,E,YAAmB,E,YAAA,G,YAAoB,E,MAApB,G,YAAnB,G,AACA,E,YAAY,E,YAAA,GAAZ,G,AACA,E,YAAa,E,YAAA,G,YAAA,GAAb,G,AACA,E,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","sourceRoot":"./debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/debug.wat b/build/debug.wat index cfbba47..1cf935a 100644 --- a/build/debug.wat +++ b/build/debug.wat @@ -14,23 +14,24 @@ (type $12 (func (param i64 i32) (result i32))) (type $13 (func (param i32 i64) (result i32))) (type $14 (func (param i64) (result i32))) - (type $15 (func (param i32 i32 i64))) + (type $15 (func (param i32 i32 i64 i32))) (type $16 (func (param i32 i32 i32 i32))) - (type $17 (func (param i64 i32 i32) (result i32))) - (type $18 (func (param i32 i32 i64) (result i32))) - (type $19 (func (param i32 i64 i32))) - (type $20 (func (param i32 i32) (result i64))) - (type $21 (func (param i32 i64 i32 i32) (result i32))) - (type $22 (func (param i32 i32 i32 i32 i64))) - (type $23 (func (param i32 i32 i64 i32) (result i32))) - (type $24 (func (param i64) (result i64))) - (type $25 (func (param i32 i32 i32 i32 i32))) - (type $26 (func (param i32 i64 i32 i32))) - (type $27 (func (param i32 i32 i64 i32 i32))) - (type $28 (func (param i32 i32 i32 i32 i32) (result i32))) - (type $29 (func (param i32 i32 i64 i32))) - (type $30 (func (result i64))) - (type $31 (func (param i64))) + (type $17 (func (param i32 f64 i64 i32 i32))) + (type $18 (func (param i32 i32 i32 i32 i64 i32))) + (type $19 (func (param i64 i32 i32) (result i32))) + (type $20 (func (param i32 i64 i32 i32 i32) (result i32))) + (type $21 (func (param i32 i32 i64) (result i32))) + (type $22 (func (param i32 i32 i64))) + (type $23 (func (param i32 i64 i32))) + (type $24 (func (param i32 i32) (result i64))) + (type $25 (func (param i32 i32 i32 i32 i32 i32 i32) (result i32))) + (type $26 (func (param i32 i32 i64 i32) (result i32))) + (type $27 (func (param i64) (result i64))) + (type $28 (func (param i32 i32 i32 i32 i32))) + (type $29 (func (param i32 i64 i32 i32))) + (type $30 (func (param i32 i32 i32 i32 i32) (result i32))) + (type $31 (func (result i64))) + (type $32 (func (param i64))) (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) (global $assembly/arguments/Arguments.Zero i32 (i32.const 0)) @@ -71,9 +72,11 @@ (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) (global $assembly/registers/NO_OF_REGISTERS i32 (i32.const 13)) (global $assembly/registers/REG_SIZE_BYTES i32 (i32.const 8)) - (global $assembly/memory-page/PAGE_SIZE i32 (i32.const 4096)) - (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) (global $~lib/native/ASC_SHRINK_LEVEL i32 (i32.const 0)) + (global $assembly/memory-page/PAGE_SIZE (mut i32) (i32.const 0)) + (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) + (global $assembly/memory-page/SEGMENT_SIZE (mut i32) (i32.const 0)) + (global $assembly/memory-page/SEGMENT_SIZE_SHIFT i32 (i32.const 16)) (global $assembly/memory-page/RESERVED_MEMORY (mut i32) (i32.const 0)) (global $assembly/memory-page/RESERVED_PAGES (mut i32) (i32.const 0)) (global $assembly/memory-page/ALLOCATE_EAGERLY (mut i32) (i32.const 0)) @@ -177,66 +180,66 @@ (global $assembly/instructions/math/max_u i32 (i32.const 11200)) (global $assembly/instructions/math/min i32 (i32.const 11232)) (global $assembly/instructions/math/min_u i32 (i32.const 11264)) - (global $assembly/instructions/mov/move_reg i32 (i32.const 11296)) - (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11328)) - (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11360)) - (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11392)) - (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11424)) - (global $assembly/instructions/rot/rot_r_64_imm i32 (i32.const 11456)) - (global $assembly/instructions/rot/rot_r_64_imm_alt i32 (i32.const 11488)) - (global $assembly/instructions/rot/rot_r_32_imm i32 (i32.const 11520)) - (global $assembly/instructions/rot/rot_r_32_imm_alt i32 (i32.const 11552)) - (global $assembly/instructions/rot/rot_l_64 i32 (i32.const 11584)) - (global $assembly/instructions/rot/rot_l_32 i32 (i32.const 11616)) - (global $assembly/instructions/rot/rot_r_64 i32 (i32.const 11648)) - (global $assembly/instructions/rot/rot_r_32 i32 (i32.const 11680)) - (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 11712)) - (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 11744)) - (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 11776)) - (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 11808)) - (global $assembly/instructions/set/set_lt_u i32 (i32.const 11840)) - (global $assembly/instructions/set/set_lt_s i32 (i32.const 11872)) + (global $assembly/instructions/misc/INVALID i32 (i32.const 11296)) + (global $assembly/instructions/misc/trap i32 (i32.const 11328)) + (global $assembly/instructions/misc/fallthrough i32 (i32.const 11360)) + (global $assembly/instructions/misc/ecalli i32 (i32.const 11392)) + (global $assembly/instructions/misc/sbrk i32 (i32.const 11568)) + (global $assembly/instructions/mov/move_reg i32 (i32.const 11600)) + (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11632)) + (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11664)) + (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11696)) + (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11728)) + (global $assembly/instructions/rot/rot_r_64_imm i32 (i32.const 11760)) + (global $assembly/instructions/rot/rot_r_64_imm_alt i32 (i32.const 11792)) + (global $assembly/instructions/rot/rot_r_32_imm i32 (i32.const 11824)) + (global $assembly/instructions/rot/rot_r_32_imm_alt i32 (i32.const 11856)) + (global $assembly/instructions/rot/rot_l_64 i32 (i32.const 11888)) + (global $assembly/instructions/rot/rot_l_32 i32 (i32.const 11920)) + (global $assembly/instructions/rot/rot_r_64 i32 (i32.const 11952)) + (global $assembly/instructions/rot/rot_r_32 i32 (i32.const 11984)) + (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 12016)) + (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 12048)) + (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 12080)) + (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 12112)) + (global $assembly/instructions/set/set_lt_u i32 (i32.const 12144)) + (global $assembly/instructions/set/set_lt_s i32 (i32.const 12176)) (global $assembly/instructions/shift/MAX_SHIFT_64 i32 (i32.const 64)) (global $assembly/instructions/shift/MAX_SHIFT_32 i32 (i32.const 32)) - (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 11904)) - (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 11936)) - (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 11968)) - (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 12000)) - (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 12032)) - (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 12064)) - (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 12096)) - (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 12128)) - (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 12160)) - (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 12192)) - (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 12224)) - (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 12256)) - (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 12288)) - (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 12320)) - (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12352)) - (global $assembly/instructions/shift/shlo_l i32 (i32.const 12384)) - (global $assembly/instructions/shift/shlo_r i32 (i32.const 12416)) - (global $assembly/instructions/shift/shar_r i32 (i32.const 12448)) - (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12480)) - (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12512)) - (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12544)) - (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12576)) - (global $assembly/instructions/store/store_u8 i32 (i32.const 12608)) - (global $assembly/instructions/store/store_u16 i32 (i32.const 12640)) - (global $assembly/instructions/store/store_u32 i32 (i32.const 12672)) - (global $assembly/instructions/store/store_u64 i32 (i32.const 12704)) - (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 12736)) - (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 12768)) - (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 12800)) - (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 12832)) - (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 12864)) - (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 12896)) - (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 12928)) - (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 12960)) - (global $assembly/instructions/misc/INVALID i32 (i32.const 12992)) - (global $assembly/instructions/misc/trap i32 (i32.const 13024)) - (global $assembly/instructions/misc/fallthrough i32 (i32.const 13056)) - (global $assembly/instructions/misc/ecalli i32 (i32.const 13088)) - (global $assembly/instructions/misc/sbrk i32 (i32.const 13264)) + (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 12208)) + (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 12240)) + (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 12272)) + (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 12304)) + (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 12336)) + (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 12368)) + (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 12400)) + (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 12432)) + (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 12464)) + (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 12496)) + (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 12528)) + (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 12560)) + (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 12592)) + (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 12624)) + (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12656)) + (global $assembly/instructions/shift/shlo_l i32 (i32.const 12688)) + (global $assembly/instructions/shift/shlo_r i32 (i32.const 12720)) + (global $assembly/instructions/shift/shar_r i32 (i32.const 12752)) + (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12784)) + (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12816)) + (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12848)) + (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12880)) + (global $assembly/instructions/store/store_u8 i32 (i32.const 12912)) + (global $assembly/instructions/store/store_u16 i32 (i32.const 12944)) + (global $assembly/instructions/store/store_u32 i32 (i32.const 12976)) + (global $assembly/instructions/store/store_u64 i32 (i32.const 13008)) + (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 13040)) + (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 13072)) + (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 13104)) + (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 13136)) + (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 13168)) + (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 13200)) + (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 13232)) + (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 13264)) (global $assembly/instructions-exe/RUN i32 (i32.const 14240)) (global $assembly/codec/MASKS i32 (i32.const 14320)) (global $assembly/codec/variableLength i32 (i32.const 14368)) @@ -256,16 +259,19 @@ (global $assembly/interpreter/EXIT i32 (i32.const -65536)) (global $assembly/interpreter/JUMP_ALIGMENT_FACTOR i32 (i32.const 2)) (global $assembly/interpreter/MAX_U32 (mut i64) (i64.const 0)) - (global $assembly/api/interpreter (mut i32) (i32.const 0)) - (global $assembly/index/InputKind.Generic i32 (i32.const 0)) - (global $assembly/index/InputKind.SPI i32 (i32.const 1)) - (global $assembly/index/HasMetadata.Yes i32 (i32.const 0)) - (global $assembly/index/HasMetadata.No i32 (i32.const 1)) + (global $assembly/spi/MAX_ARGS_LEN (mut i32) (i32.const 0)) + (global $assembly/spi/ARGS_SEGMENT_START (mut i32) (i32.const 0)) + (global $assembly/spi/STACK_SEGMENT_END (mut i32) (i32.const 0)) + (global $assembly/api-debugger/interpreter (mut i32) (i32.const 0)) + (global $assembly/api-utils/InputKind.Generic i32 (i32.const 0)) + (global $assembly/api-utils/InputKind.SPI i32 (i32.const 1)) + (global $assembly/api-utils/HasMetadata.Yes i32 (i32.const 0)) + (global $assembly/api-utils/HasMetadata.No i32 (i32.const 1)) (global $~lib/builtins/u32.MAX_VALUE i32 (i32.const -1)) - (global $~lib/rt/__rtti_base i32 (i32.const 20032)) - (global $~lib/memory/__data_end i32 (i32.const 20276)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 53044)) - (global $~lib/memory/__heap_base i32 (i32.const 53044)) + (global $~lib/rt/__rtti_base i32 (i32.const 20480)) + (global $~lib/memory/__data_end i32 (i32.const 20740)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 53508)) + (global $~lib/memory/__heap_base i32 (i32.const 53508)) (memory $0 1) (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") @@ -529,162 +535,172 @@ (data $259 (i32.const 11308) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") (data $260 (i32.const 11340) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") (data $261 (i32.const 11372) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") - (data $262 (i32.const 11404) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") - (data $263 (i32.const 11436) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00e\00\00\00\00\00\00\00\00\00\00\00") - (data $264 (i32.const 11468) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00f\00\00\00\00\00\00\00\00\00\00\00") - (data $265 (i32.const 11500) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00g\00\00\00\00\00\00\00\00\00\00\00") - (data $266 (i32.const 11532) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00h\00\00\00\00\00\00\00\00\00\00\00") - (data $267 (i32.const 11564) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00i\00\00\00\00\00\00\00\00\00\00\00") - (data $268 (i32.const 11596) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00j\00\00\00\00\00\00\00\00\00\00\00") - (data $269 (i32.const 11628) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00k\00\00\00\00\00\00\00\00\00\00\00") - (data $270 (i32.const 11660) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00l\00\00\00\00\00\00\00\00\00\00\00") - (data $271 (i32.const 11692) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00m\00\00\00\00\00\00\00\00\00\00\00") - (data $272 (i32.const 11724) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00n\00\00\00\00\00\00\00\00\00\00\00") - (data $273 (i32.const 11756) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00o\00\00\00\00\00\00\00\00\00\00\00") - (data $274 (i32.const 11788) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00p\00\00\00\00\00\00\00\00\00\00\00") - (data $275 (i32.const 11820) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00q\00\00\00\00\00\00\00\00\00\00\00") - (data $276 (i32.const 11852) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00r\00\00\00\00\00\00\00\00\00\00\00") - (data $277 (i32.const 11884) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $278 (i32.const 11916) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00t\00\00\00\00\00\00\00\00\00\00\00") - (data $279 (i32.const 11948) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00u\00\00\00\00\00\00\00\00\00\00\00") - (data $280 (i32.const 11980) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00v\00\00\00\00\00\00\00\00\00\00\00") - (data $281 (i32.const 12012) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00w\00\00\00\00\00\00\00\00\00\00\00") - (data $282 (i32.const 12044) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00x\00\00\00\00\00\00\00\00\00\00\00") - (data $283 (i32.const 12076) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00y\00\00\00\00\00\00\00\00\00\00\00") - (data $284 (i32.const 12108) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00z\00\00\00\00\00\00\00\00\00\00\00") - (data $285 (i32.const 12140) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00{\00\00\00\00\00\00\00\00\00\00\00") - (data $286 (i32.const 12172) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00|\00\00\00\00\00\00\00\00\00\00\00") - (data $287 (i32.const 12204) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00}\00\00\00\00\00\00\00\00\00\00\00") - (data $288 (i32.const 12236) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00~\00\00\00\00\00\00\00\00\00\00\00") - (data $289 (i32.const 12268) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\7f\00\00\00\00\00\00\00\00\00\00\00") - (data $290 (i32.const 12300) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\80\00\00\00\00\00\00\00\00\00\00\00") - (data $291 (i32.const 12332) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\81\00\00\00\00\00\00\00\00\00\00\00") - (data $292 (i32.const 12364) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\82\00\00\00\00\00\00\00\00\00\00\00") - (data $293 (i32.const 12396) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\83\00\00\00\00\00\00\00\00\00\00\00") - (data $294 (i32.const 12428) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\84\00\00\00\00\00\00\00\00\00\00\00") - (data $295 (i32.const 12460) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\85\00\00\00\00\00\00\00\00\00\00\00") - (data $296 (i32.const 12492) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\86\00\00\00\00\00\00\00\00\00\00\00") - (data $297 (i32.const 12524) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\87\00\00\00\00\00\00\00\00\00\00\00") - (data $298 (i32.const 12556) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\88\00\00\00\00\00\00\00\00\00\00\00") - (data $299 (i32.const 12588) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\89\00\00\00\00\00\00\00\00\00\00\00") - (data $300 (i32.const 12620) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8a\00\00\00\00\00\00\00\00\00\00\00") - (data $301 (i32.const 12652) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8b\00\00\00\00\00\00\00\00\00\00\00") - (data $302 (i32.const 12684) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8c\00\00\00\00\00\00\00\00\00\00\00") - (data $303 (i32.const 12716) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8d\00\00\00\00\00\00\00\00\00\00\00") - (data $304 (i32.const 12748) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8e\00\00\00\00\00\00\00\00\00\00\00") - (data $305 (i32.const 12780) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8f\00\00\00\00\00\00\00\00\00\00\00") - (data $306 (i32.const 12812) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\90\00\00\00\00\00\00\00\00\00\00\00") - (data $307 (i32.const 12844) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\91\00\00\00\00\00\00\00\00\00\00\00") - (data $308 (i32.const 12876) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\92\00\00\00\00\00\00\00\00\00\00\00") - (data $309 (i32.const 12908) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\93\00\00\00\00\00\00\00\00\00\00\00") - (data $310 (i32.const 12940) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\94\00\00\00\00\00\00\00\00\00\00\00") - (data $311 (i32.const 12972) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\95\00\00\00\00\00\00\00\00\00\00\00") - (data $312 (i32.const 13004) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\96\00\00\00\00\00\00\00\00\00\00\00") - (data $313 (i32.const 13036) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\97\00\00\00\00\00\00\00\00\00\00\00") - (data $314 (i32.const 13068) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\98\00\00\00\00\00\00\00\00\00\00\00") - (data $315 (i32.const 13100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y\00") - (data $316 (i32.const 13148) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.\00") + (data $262 (i32.const 11404) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y\00") + (data $263 (i32.const 11452) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.\00") + (data $264 (i32.const 11548) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") + (data $265 (i32.const 11580) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00e\00\00\00\00\00\00\00\00\00\00\00") + (data $266 (i32.const 11612) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00f\00\00\00\00\00\00\00\00\00\00\00") + (data $267 (i32.const 11644) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00g\00\00\00\00\00\00\00\00\00\00\00") + (data $268 (i32.const 11676) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00h\00\00\00\00\00\00\00\00\00\00\00") + (data $269 (i32.const 11708) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00i\00\00\00\00\00\00\00\00\00\00\00") + (data $270 (i32.const 11740) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00j\00\00\00\00\00\00\00\00\00\00\00") + (data $271 (i32.const 11772) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00k\00\00\00\00\00\00\00\00\00\00\00") + (data $272 (i32.const 11804) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00l\00\00\00\00\00\00\00\00\00\00\00") + (data $273 (i32.const 11836) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00m\00\00\00\00\00\00\00\00\00\00\00") + (data $274 (i32.const 11868) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00n\00\00\00\00\00\00\00\00\00\00\00") + (data $275 (i32.const 11900) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00o\00\00\00\00\00\00\00\00\00\00\00") + (data $276 (i32.const 11932) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00p\00\00\00\00\00\00\00\00\00\00\00") + (data $277 (i32.const 11964) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00q\00\00\00\00\00\00\00\00\00\00\00") + (data $278 (i32.const 11996) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00r\00\00\00\00\00\00\00\00\00\00\00") + (data $279 (i32.const 12028) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $280 (i32.const 12060) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00t\00\00\00\00\00\00\00\00\00\00\00") + (data $281 (i32.const 12092) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00u\00\00\00\00\00\00\00\00\00\00\00") + (data $282 (i32.const 12124) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00v\00\00\00\00\00\00\00\00\00\00\00") + (data $283 (i32.const 12156) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00w\00\00\00\00\00\00\00\00\00\00\00") + (data $284 (i32.const 12188) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00x\00\00\00\00\00\00\00\00\00\00\00") + (data $285 (i32.const 12220) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00y\00\00\00\00\00\00\00\00\00\00\00") + (data $286 (i32.const 12252) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00z\00\00\00\00\00\00\00\00\00\00\00") + (data $287 (i32.const 12284) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00{\00\00\00\00\00\00\00\00\00\00\00") + (data $288 (i32.const 12316) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00|\00\00\00\00\00\00\00\00\00\00\00") + (data $289 (i32.const 12348) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00}\00\00\00\00\00\00\00\00\00\00\00") + (data $290 (i32.const 12380) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00~\00\00\00\00\00\00\00\00\00\00\00") + (data $291 (i32.const 12412) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\7f\00\00\00\00\00\00\00\00\00\00\00") + (data $292 (i32.const 12444) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\80\00\00\00\00\00\00\00\00\00\00\00") + (data $293 (i32.const 12476) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\81\00\00\00\00\00\00\00\00\00\00\00") + (data $294 (i32.const 12508) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\82\00\00\00\00\00\00\00\00\00\00\00") + (data $295 (i32.const 12540) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\83\00\00\00\00\00\00\00\00\00\00\00") + (data $296 (i32.const 12572) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\84\00\00\00\00\00\00\00\00\00\00\00") + (data $297 (i32.const 12604) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\85\00\00\00\00\00\00\00\00\00\00\00") + (data $298 (i32.const 12636) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\86\00\00\00\00\00\00\00\00\00\00\00") + (data $299 (i32.const 12668) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\87\00\00\00\00\00\00\00\00\00\00\00") + (data $300 (i32.const 12700) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\88\00\00\00\00\00\00\00\00\00\00\00") + (data $301 (i32.const 12732) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\89\00\00\00\00\00\00\00\00\00\00\00") + (data $302 (i32.const 12764) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8a\00\00\00\00\00\00\00\00\00\00\00") + (data $303 (i32.const 12796) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8b\00\00\00\00\00\00\00\00\00\00\00") + (data $304 (i32.const 12828) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8c\00\00\00\00\00\00\00\00\00\00\00") + (data $305 (i32.const 12860) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8d\00\00\00\00\00\00\00\00\00\00\00") + (data $306 (i32.const 12892) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8e\00\00\00\00\00\00\00\00\00\00\00") + (data $307 (i32.const 12924) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8f\00\00\00\00\00\00\00\00\00\00\00") + (data $308 (i32.const 12956) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\90\00\00\00\00\00\00\00\00\00\00\00") + (data $309 (i32.const 12988) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\91\00\00\00\00\00\00\00\00\00\00\00") + (data $310 (i32.const 13020) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\92\00\00\00\00\00\00\00\00\00\00\00") + (data $311 (i32.const 13052) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\93\00\00\00\00\00\00\00\00\00\00\00") + (data $312 (i32.const 13084) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\94\00\00\00\00\00\00\00\00\00\00\00") + (data $313 (i32.const 13116) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\95\00\00\00\00\00\00\00\00\00\00\00") + (data $314 (i32.const 13148) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\96\00\00\00\00\00\00\00\00\00\00\00") + (data $315 (i32.const 13180) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\97\00\00\00\00\00\00\00\00\00\00\00") + (data $316 (i32.const 13212) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\98\00\00\00\00\00\00\00\00\00\00\00") (data $317 (i32.const 13244) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\99\00\00\00\00\00\00\00\00\00\00\00") - (data $318 (i32.const 13276) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00\e02\00\00\003\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 3\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00`$\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c00\00\00\e00\00\00\001\00\00 1\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\e0#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\00$\00\00\80$\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00@1\00\00`1\00\00\801\00\00\a01\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c01\00\00\e01\00\00\002\00\00 2\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 $\00\00\e0!\00\00\00\"\00\00 \"\00\00@\"\00\00`\"\00\00\80\"\00\00\a0\"\00\00\c0\"\00\00\e0\"\00\00\00#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 ,\00\00\d03\00\00\a0 \00\00\c0 \00\00\e0 \00\00\00!\00\00 !\00\00@!\00\00`!\00\00\80!\00\00\a0!\00\00\c0!\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00@2\00\00`2\00\00\802\00\00\a02\00\00\c0&\00\00\e0&\00\00\00\'\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\c0(\00\00\a0\'\00\00\c0\'\00\00\e0\'\00\00\e0(\00\00\c0-\00\00\e0-\00\00\80.\00\00\a0.\00\00\c0.\00\00\00)\00\00\00.\00\00 .\00\00\e0.\00\00\00/\00\00 /\00\00@,\00\00`,\00\00 )\00\00@)\00\00@/\00\00`/\00\00\80/\00\00`)\00\00\a0/\00\00\c0/\00\00\e0/\00\00\c0,\00\00\e0,\00\00\00-\00\00 -\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00 #\00\00@#\00\00`#\00\00\80#\00\00\a0#\00\00\c0#\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00@$\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\c02\00\00\80)\00\00\a0)\00\00\c0)\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\00\000\00\00 0\00\00@0\00\00`*\00\00\80*\00\00\a0*\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00`0\00\00\800\00\00\a00\00\00\00(\00\00 (\00\00@(\00\00@+\00\00`+\00\00\80+\00\00@.\00\00`.\00\00\80,\00\00\a0,\00\00@-\00\00`-\00\00\80-\00\00\a0-\00\00`(\00\00\80(\00\00\a0(\00\00\a0+\00\00\c0+\00\00\e0+\00\00\00,\00\00") + (data $318 (i32.const 13276) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00@,\00\00`,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\80,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00`$\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\f01\00\00\102\00\0002\00\00P2\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\e0#\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\00$\00\00\80$\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00p2\00\00\902\00\00\b02\00\00\d02\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\f02\00\00\103\00\0003\00\00P3\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 $\00\00\e0!\00\00\00\"\00\00 \"\00\00@\"\00\00`\"\00\00\80\"\00\00\a0\"\00\00\c0\"\00\00\e0\"\00\00\00#\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00P-\00\000-\00\00\a0 \00\00\c0 \00\00\e0 \00\00\00!\00\00 !\00\00@!\00\00`!\00\00\80!\00\00\a0!\00\00\c0!\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00p3\00\00\903\00\00\b03\00\00\d03\00\00\c0&\00\00\e0&\00\00\00\'\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\c0(\00\00\a0\'\00\00\c0\'\00\00\e0\'\00\00\e0(\00\00\f0.\00\00\10/\00\00\b0/\00\00\d0/\00\00\f0/\00\00\00)\00\000/\00\00P/\00\00\100\00\0000\00\00P0\00\00p-\00\00\90-\00\00 )\00\00@)\00\00p0\00\00\900\00\00\b00\00\00`)\00\00\d00\00\00\f00\00\00\101\00\00\f0-\00\00\10.\00\000.\00\00P.\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 #\00\00@#\00\00`#\00\00\80#\00\00\a0#\00\00\c0#\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00@$\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\80)\00\00\a0)\00\00\c0)\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\0001\00\00P1\00\00p1\00\00`*\00\00\80*\00\00\a0*\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00\901\00\00\b01\00\00\d01\00\00\00(\00\00 (\00\00@(\00\00@+\00\00`+\00\00\80+\00\00p/\00\00\90/\00\00\b0-\00\00\d0-\00\00p.\00\00\90.\00\00\b0.\00\00\d0.\00\00`(\00\00\80(\00\00\a0(\00\00\a0+\00\00\c0+\00\00\e0+\00\00\00,\00\00") (data $319 (i32.const 14220) ",\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\10\00\00\00\f03\00\00\f03\00\00\9c\03\00\00\e7\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") (data $320 (i32.const 14268) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80\00\00\00\00") (data $321 (i32.const 14300) ",\00\00\00\00\00\00\00\00\00\00\00\1b\00\00\00\10\00\00\00\d07\00\00\d07\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") (data $322 (i32.const 14348) "\1c\00\00\00\00\00\00\00\00\00\00\00\1c\00\00\00\08\00\00\00\9a\00\00\00\00\00\00\00\00\00\00\00") - (data $323 (i32.const 14380) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $324 (i32.const 14412) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 \00\00\00") - (data $325 (i32.const 14492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $326 (i32.const 14540) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00`8\00\00\00\00\00\00\b08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $327 (i32.const 14588) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006\00\00\00\00\00\00\00\00\00") - (data $328 (i32.const 14716) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") - (data $329 (i32.const 14780) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\000\00\00\00\00\00\00\00\00\00\00\00") - (data $330 (i32.const 14812) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\00") - (data $331 (i32.const 15212) "\1c\04\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $332 (i32.const 16268) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z\00\00\00\00\00") - (data $333 (i32.const 16364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $334 (i32.const 16428) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 \00\00\00\00\00\00\00\00\00") - (data $335 (i32.const 16540) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $336 (i32.const 16588) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00@@\00\00\00\00\00\00\b0@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $337 (i32.const 16636) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n\00\00\00\00\00\00\00") - (data $338 (i32.const 16684) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\000\00x\00\00\00\00\00\00\00\00\00") - (data $339 (i32.const 16716) "\1c\00\00\00\00\00\00\00\00\00\00\00)\00\00\00\08\00\00\00\9b\00\00\00\00\00\00\00\00\00\00\00") - (data $340 (i32.const 16748) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00\n\00\n\00\00\00\00\00\00\00\00\00") - (data $341 (i32.const 16780) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $342 (i32.const 16908) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>\00\00\00") - (data $343 (i32.const 16988) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!\00\00\00\00\00\00\00\00\00\00\00") - (data $344 (i32.const 17100) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00g\00e\00n\00e\00r\00i\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $345 (i32.const 17180) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") - (data $346 (i32.const 17212) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00:\00 \00\00\00\00\00\00\00\00\00") - (data $347 (i32.const 17244) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") - (data $348 (i32.const 17276) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") - (data $349 (i32.const 17308) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pC\00\00\00\00\00\00\90C\00\00") - (data $350 (i32.const 17340) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $351 (i32.const 17372) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00,\00 \00\00\00\00\00\00\00\00\00") - (data $352 (i32.const 17404) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00\d0C\00\00\00\00\00\00\f0C\00\00") - (data $353 (i32.const 17436) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") - (data $354 (i32.const 17564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 \00") - (data $355 (i32.const 17612) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $356 (i32.const 17644) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $357 (i32.const 17676) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $358 (i32.const 17708) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $359 (i32.const 17740) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 \00") - (data $360 (i32.const 17836) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $361 (i32.const 17900) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!\00\00\00\00\00\00\00") - (data $362 (i32.const 18012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 \00\00\00\00\00") - (data $363 (i32.const 18060) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $364 (i32.const 18108) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pF\00\00\00\00\00\00\a0F\00\00") - (data $365 (i32.const 18140) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pF\00\00\00\00\00\00\a0F\00\00") - (data $366 (i32.const 18172) "\1c\00\00\00\00\00\00\00\00\00\00\005\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") - (data $367 (i32.const 18204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 \00") - (data $368 (i32.const 18268) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00P\00C\00 \00=\00 \00\00\00") - (data $369 (i32.const 18300) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $370 (i32.const 18348) "\1c\00\00\00\00\00\00\00\00\00\00\005\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") - (data $371 (i32.const 18380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 \00") - (data $372 (i32.const 18428) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00(\00\00\00\00\00\00\00\00\00") - (data $373 (i32.const 18460) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\14\00\00\00\e0G\00\00\00\00\00\00\10H\00\00\00\00\00\00\90C\00\00\00\00\00\00\00\00\00\00") - (data $374 (i32.const 18508) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 \00\00\00\00\00\00\00\00\00") - (data $375 (i32.const 18588) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00") - (data $376 (i32.const 18652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 \00\00\00") - (data $377 (i32.const 18700) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x\00") - (data $378 (i32.const 18732) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 \00\00\00") - (data $379 (i32.const 18764) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00,\00\n\00 \00 \00\00\00\00\00") - (data $380 (i32.const 18796) "|\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00`\00\00\00\f0H\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00@I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00`I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00`I\00\00\00\00\00\00\10H\00\00\00\00\00\00 I\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $381 (i32.const 18924) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t\00") - (data $382 (i32.const 18972) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $383 (i32.const 19052) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $384 (i32.const 19084) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $385 (i32.const 19116) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $386 (i32.const 19148) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $387 (i32.const 19180) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00S\00P\00I\00 \00r\00u\00n\00n\00i\00n\00g\00 \00n\00o\00t\00 \00s\00u\00p\00p\00o\00r\00t\00e\00d\00 \00y\00e\00t\00\00\00") - (data $388 (i32.const 19260) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00d\00e\00x\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $389 (i32.const 19324) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $390 (i32.const 19404) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $391 (i32.const 19436) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $392 (i32.const 19500) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 \00\00\00\00\00\00\00") - (data $393 (i32.const 19580) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00") - (data $394 (i32.const 19676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 \00\00\00\00\00") - (data $395 (i32.const 19724) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00\90L\00\00\00\00\00\00\f0L\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $396 (i32.const 19772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $397 (i32.const 19836) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $398 (i32.const 19868) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $399 (i32.const 19900) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d\00\00\00") - (data $400 (i32.const 19964) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d\00\00\00\00\00") - (data $401 (i32.const 20032) "<\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\02A\00\00B\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\01\00\00\00\00\00\00\00\00\00\00$\t\00\00 \00\00\00\00\00\00\00\00\00\00\00\04A\00\00 \00\00\00\00\00\00\00\02\01\00\00\02\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00\00\00\00\00 \00\00\00 \00\00\00\02A\00\00d\00\00\00\00\00\00\00") + (data $323 (i32.const 14380) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>\00\00\00") + (data $324 (i32.const 14460) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $325 (i32.const 14492) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!\00\00\00\00\00\00\00\00\00\00\00") + (data $326 (i32.const 14604) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00i\00n\00t\00e\00r\00n\00a\00l\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $327 (i32.const 14684) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $328 (i32.const 14812) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") + (data $329 (i32.const 14844) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006\00\00\00\00\00\00\00\00\00") + (data $330 (i32.const 14972) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") + (data $331 (i32.const 15036) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\000\00\00\00\00\00\00\00\00\00\00\00") + (data $332 (i32.const 15068) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\00") + (data $333 (i32.const 15468) "\1c\04\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $334 (i32.const 16524) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z\00\00\00\00\00") + (data $335 (i32.const 16620) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00:\00 \00\00\00\00\00\00\00\00\00") + (data $336 (i32.const 16652) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") + (data $337 (i32.const 16684) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") + (data $338 (i32.const 16716) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00 A\00\00\00\00\00\00@A\00\00") + (data $339 (i32.const 16748) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $340 (i32.const 16780) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00,\00 \00\00\00\00\00\00\00\00\00") + (data $341 (i32.const 16812) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\80A\00\00\00\00\00\00\a0A\00\00") + (data $342 (i32.const 16844) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 \00\00\00\00\00\00\00\00\00") + (data $343 (i32.const 16924) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $344 (i32.const 17004) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $345 (i32.const 17036) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $346 (i32.const 17100) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 \00\00\00\00\00\00\00") + (data $347 (i32.const 17180) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $348 (i32.const 17244) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 \00\00\00") + (data $349 (i32.const 17324) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $350 (i32.const 17372) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00pC\00\00\00\00\00\00\c0C\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $351 (i32.const 17420) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 \00\00\00\00\00\00\00\00\00") + (data $352 (i32.const 17532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $353 (i32.const 17580) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00 D\00\00\00\00\00\00\90D\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $354 (i32.const 17628) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00A\00r\00g\00u\00m\00e\00n\00t\00s\00 \00l\00e\00n\00g\00t\00h\00 \00i\00s\00 \00t\00o\00o\00 \00b\00i\00g\00.\00 \00G\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00") + (data $355 (i32.const 17724) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00m\00a\00x\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $356 (i32.const 17772) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00\f0D\00\00\00\00\00\00PE\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $357 (i32.const 17820) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00s\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $358 (i32.const 17884) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") + (data $359 (i32.const 18012) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $360 (i32.const 18044) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 \00") + (data $361 (i32.const 18140) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $362 (i32.const 18204) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!\00\00\00\00\00\00\00") + (data $363 (i32.const 18316) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00d\00e\00b\00u\00g\00g\00e\00r\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $364 (i32.const 18396) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00") + (data $365 (i32.const 18492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 \00\00\00\00\00") + (data $366 (i32.const 18540) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00\f0G\00\00\00\00\00\00PH\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $367 (i32.const 18588) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $368 (i32.const 18620) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $369 (i32.const 18652) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $370 (i32.const 18684) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t\00") + (data $371 (i32.const 18732) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $372 (i32.const 18812) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $373 (i32.const 18844) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $374 (i32.const 18876) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $375 (i32.const 18908) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $376 (i32.const 18940) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 \00") + (data $377 (i32.const 18988) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00u\00t\00i\00l\00s\00.\00t\00s\00\00\00") + (data $378 (i32.const 19052) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00g\00a\00s\00-\00c\00o\00s\00t\00s\00.\00t\00s\00\00\00") + (data $379 (i32.const 19116) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $380 (i32.const 19148) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $381 (i32.const 19180) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $382 (i32.const 19212) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $383 (i32.const 19244) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n\00\00\00\00\00\00\00") + (data $384 (i32.const 19292) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\000\00x\00\00\00\00\00\00\00\00\00") + (data $385 (i32.const 19324) "\1c\00\00\00\00\00\00\00\00\00\00\00:\00\00\00\08\00\00\00\9b\00\00\00\00\00\00\00\00\00\00\00") + (data $386 (i32.const 19356) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00\n\00\n\00\00\00\00\00\00\00\00\00") + (data $387 (i32.const 19388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 \00\00\00\00\00") + (data $388 (i32.const 19436) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $389 (i32.const 19484) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\d0K\00\00\00\00\00\00\00L\00\00") + (data $390 (i32.const 19516) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\d0K\00\00\00\00\00\00\00L\00\00") + (data $391 (i32.const 19548) "\1c\00\00\00\00\00\00\00\00\00\00\00>\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") + (data $392 (i32.const 19580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 \00") + (data $393 (i32.const 19644) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00P\00C\00 \00=\00 \00\00\00") + (data $394 (i32.const 19676) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00G\00A\00S\00 \00=\00 \00") + (data $395 (i32.const 19708) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $396 (i32.const 19756) "\1c\00\00\00\00\00\00\00\00\00\00\00>\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") + (data $397 (i32.const 19788) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 \00") + (data $398 (i32.const 19836) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00(\00\00\00\00\00\00\00\00\00") + (data $399 (i32.const 19868) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\14\00\00\00`M\00\00\00\00\00\00\90M\00\00\00\00\00\00@A\00\00\00\00\00\00\00\00\00\00") + (data $400 (i32.const 19916) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00") + (data $401 (i32.const 19980) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 \00\00\00") + (data $402 (i32.const 20028) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x\00") + (data $403 (i32.const 20060) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 \00\00\00") + (data $404 (i32.const 20092) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00,\00\n\00 \00 \00\00\00\00\00") + (data $405 (i32.const 20124) "|\00\00\00\03\00\00\00\00\00\00\00%\00\00\00`\00\00\00 N\00\00\00\00\00\00\90M\00\00\00\00\00\00PN\00\00\00\00\00\00pN\00\00\00\00\00\00\90M\00\00\00\00\00\00PN\00\00\00\00\00\00\90N\00\00\00\00\00\00\90M\00\00\00\00\00\00PN\00\00\00\00\00\00\90N\00\00\00\00\00\00\90M\00\00\00\00\00\00PN\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $406 (i32.const 20252) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $407 (i32.const 20284) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $408 (i32.const 20316) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $409 (i32.const 20348) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d\00\00\00") + (data $410 (i32.const 20412) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d\00\00\00\00\00") + (data $411 (i32.const 20480) "@\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\02A\00\00B\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\01\00\00\00\00\00\00\00\00\00\00$\t\00\00 \00\00\00\04A\00\00\02\01\00\00d\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00 \00\00\00\00\00\00\00\00\00\00\00 \00\00\00\02A\00\00 \00\00\00\02A\00\00\00\00\00\00\02A\00\00 \00\00\00 \00\00\00 \00\00\00\02A\00\00\02\02\00\00\10A\02\00\00\00\00\00\00\00\00\00\00\00\00\00\02A\00\00\00\00\00\00\00\00\00\00") (table $0 158 158 funcref) - (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $assembly/index/disassemble~anonymous|0 $assembly/api-generic/runVm~anonymous|0 $assembly/api-generic/runVm~anonymous|1) - (export "InputKind.Generic" (global $assembly/index/InputKind.Generic)) - (export "InputKind.SPI" (global $assembly/index/InputKind.SPI)) - (export "HasMetadata.Yes" (global $assembly/index/HasMetadata.Yes)) - (export "HasMetadata.No" (global $assembly/index/HasMetadata.No)) - (export "nextStep" (func $assembly/api/nextStep)) - (export "nSteps" (func $assembly/api/nSteps)) - (export "getProgramCounter" (func $assembly/api/getProgramCounter)) - (export "setNextProgramCounter" (func $assembly/api/setNextProgramCounter)) - (export "getStatus" (func $assembly/api/getStatus)) - (export "getExitArg" (func $assembly/api/getExitArg)) - (export "getGasLeft" (func $assembly/api/getGasLeft)) - (export "setGasLeft" (func $assembly/api/setGasLeft)) - (export "getRegisters" (func $assembly/api/getRegisters)) - (export "getPageDump" (func $assembly/api/getPageDump)) + (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/codec~anonymous|0 $assembly/api-utils/disassemble~anonymous|0 $assembly/api-internal/executeProgram~anonymous|0 $assembly/api-internal/executeProgram~anonymous|1) + (export "nextStep" (func $assembly/api-debugger/nextStep)) + (export "nSteps" (func $assembly/api-debugger/nSteps)) + (export "getProgramCounter" (func $assembly/api-debugger/getProgramCounter)) + (export "setNextProgramCounter" (func $assembly/api-debugger/setNextProgramCounter)) + (export "getStatus" (func $assembly/api-debugger/getStatus)) + (export "getExitArg" (func $assembly/api-debugger/getExitArg)) + (export "getGasLeft" (func $assembly/api-debugger/getGasLeft)) + (export "setGasLeft" (func $assembly/api-debugger/setGasLeft)) + (export "getRegisters" (func $assembly/api-debugger/getRegisters)) + (export "getPageDump" (func $assembly/api-debugger/getPageDump)) + (export "InputKind.Generic" (global $assembly/api-utils/InputKind.Generic)) + (export "InputKind.SPI" (global $assembly/api-utils/InputKind.SPI)) + (export "HasMetadata.Yes" (global $assembly/api-utils/HasMetadata.Yes)) + (export "HasMetadata.No" (global $assembly/api-utils/HasMetadata.No)) (export "__new" (func $~lib/rt/itcms/__new)) (export "__pin" (func $~lib/rt/itcms/__pin)) (export "__unpin" (func $~lib/rt/itcms/__unpin)) @@ -692,15 +708,17 @@ (export "__rtti_base" (global $~lib/rt/__rtti_base)) (export "memory" (memory $0)) (export "__setArgumentsLength" (func $~setArgumentsLength)) - (export "disassemble" (func $export:assembly/index/disassemble)) - (export "runProgram" (func $export:assembly/index/runProgram)) - (export "runVm" (func $export:assembly/api-generic/runVm@varargs)) - (export "getAssembly" (func $export:assembly/api-generic/getAssembly)) + (export "getAssembly" (func $export:assembly/api-internal/getAssembly)) (export "wrapAsProgram" (func $export:assembly/program-build/wrapAsProgram)) - (export "resetGeneric" (func $export:assembly/api/resetGeneric)) - (export "resetGenericWithMemory" (func $export:assembly/api/resetGenericWithMemory)) - (export "setRegisters" (func $export:assembly/api/setRegisters)) - (export "setMemory" (func $export:assembly/api/setMemory)) + (export "resetJAM" (func $export:assembly/api-debugger/resetJAM@varargs)) + (export "resetGeneric" (func $export:assembly/api-debugger/resetGeneric@varargs)) + (export "resetGenericWithMemory" (func $export:assembly/api-debugger/resetGenericWithMemory@varargs)) + (export "setRegisters" (func $export:assembly/api-debugger/setRegisters)) + (export "setMemory" (func $export:assembly/api-debugger/setMemory)) + (export "getGasCosts" (func $export:assembly/api-utils/getGasCosts)) + (export "disassemble" (func $export:assembly/api-utils/disassemble)) + (export "prepareProgram" (func $export:assembly/api-utils/prepareProgram)) + (export "runProgram" (func $export:assembly/api-utils/runProgram@varargs)) (start $~start) (func $~lib/rt/itcms/Object#set:nextWithColor (param $this i32) (param $nextWithColor i32) local.get $this @@ -3418,6 +3436,14 @@ return ) (func $start:assembly/memory-page + i32.const 2 + i32.const 12 + call $~lib/math/ipow32 + global.set $assembly/memory-page/PAGE_SIZE + i32.const 2 + i32.const 16 + call $~lib/math/ipow32 + global.set $assembly/memory-page/SEGMENT_SIZE i32.const 2 i32.const 16 call $~lib/math/ipow32 @@ -3634,9 +3660,6 @@ i64.rotr return ) - (func $start:assembly/instructions/bit - call $start:assembly/instructions/outcome - ) (func $assembly/instructions/utils/u32SignExtend (param $v i32) (result i64) local.get $v i64.extend_i32_s @@ -4426,30 +4449,6 @@ call $assembly/instructions/utils/mulUpperUnsigned return ) - (func $assembly/instructions/rot/math.rot_r (param $v i64) (param $shift i64) (result i64) - local.get $v - local.get $shift - i64.rotr - return - ) - (func $assembly/instructions/rot/math.rot_r_32 (param $v i32) (param $shift i32) (result i32) - local.get $v - local.get $shift - i32.rotr - return - ) - (func $assembly/instructions/rot/math.rot_l (param $v i64) (param $shift i64) (result i64) - local.get $v - local.get $shift - i64.rotl - return - ) - (func $assembly/instructions/rot/math.rot_l_32 (param $v i32) (param $shift i32) (result i32) - local.get $v - local.get $shift - i32.rotl - return - ) (func $assembly/instructions/outcome/panic (result i32) global.get $assembly/instructions/outcome/Result.PANIC call $assembly/instructions/outcome/status @@ -4585,9 +4584,29 @@ local.get $lastAllocatedPage i32.store ) - (func $start:assembly/instructions-exe - (local $0 i32) - call $start:assembly/instructions/bit + (func $assembly/instructions/rot/math.rot_r (param $v i64) (param $shift i64) (result i64) + local.get $v + local.get $shift + i64.rotr + return + ) + (func $assembly/instructions/rot/math.rot_r_32 (param $v i32) (param $shift i32) (result i32) + local.get $v + local.get $shift + i32.rotr + return + ) + (func $assembly/instructions/rot/math.rot_l (param $v i64) (param $shift i64) (result i64) + local.get $v + local.get $shift + i64.rotl + return + ) + (func $assembly/instructions/rot/math.rot_l_32 (param $v i32) (param $shift i32) (result i32) + local.get $v + local.get $shift + i32.rotl + return ) (func $~lib/array/Array#get:length_ (param $this i32) (result i32) local.get $this @@ -4598,41 +4617,71 @@ i32.load offset=4 ) (func $start:assembly/interpreter - call $start:assembly/instructions-exe + call $start:assembly/instructions/outcome i64.const 2 i64.const 32 call $~lib/math/ipow64 global.set $assembly/interpreter/MAX_U32 ) - (func $start:assembly/api-generic + (func $start:assembly/api-internal call $start:assembly/arguments call $start:assembly/instructions call $start:assembly/interpreter ) + (func $start:assembly/spi + i32.const 2 + i32.const 24 + call $~lib/math/ipow32 + global.set $assembly/spi/MAX_ARGS_LEN + i32.const 2 + i32.const 32 + call $~lib/math/ipow32 + global.get $assembly/memory-page/SEGMENT_SIZE + i32.sub + global.get $assembly/spi/MAX_ARGS_LEN + i32.sub + global.set $assembly/spi/ARGS_SEGMENT_START + global.get $assembly/spi/ARGS_SEGMENT_START + global.get $assembly/memory-page/SEGMENT_SIZE + i32.sub + global.set $assembly/spi/STACK_SEGMENT_END + ) + (func $start:assembly/api-debugger + call $start:assembly/api-internal + call $start:assembly/spi + ) (func $start:assembly/index - call $start:assembly/api-generic + call $start:assembly/api-debugger ) - (func $assembly/codec/Decoder#set:source (param $this i32) (param $source i32) + (func $assembly/program/Program#get:code (param $this i32) (result i32) local.get $this - local.get $source - i32.store + i32.load + ) + (func $assembly/program/Program#get:mask (param $this i32) (result i32) local.get $this - local.get $source - i32.const 0 - call $~lib/rt/itcms/__link + i32.load offset=4 ) - (func $assembly/codec/Decoder#set:offset (param $this i32) (param $offset i32) + (func $assembly/program/Mask#get:bytesToSkip (param $this i32) (result i32) local.get $this - local.get $offset - i32.store offset=4 + i32.load ) - (func $assembly/codec/Decoder#get:offset (param $this i32) (result i32) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) local.get $this - i32.load offset=4 + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return ) - (func $assembly/codec/Decoder#get:source (param $this i32) (result i32) + (func $~lib/string/String#get:length (param $this i32) (result i32) local.get $this - i32.load + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 1 + i32.shr_u + return ) (func $~lib/util/number/decimalCount32 (param $value i32) (result i32) local.get $value @@ -4724,14 +4773,14 @@ i32.const 100 i32.rem_u local.set $d2 - i32.const 14812 + i32.const 15068 local.get $d1 i32.const 2 i32.shl i32.add i64.load32_u local.set $digits1 - i32.const 14812 + i32.const 15068 local.get $d2 i32.const 2 i32.shl @@ -4774,7 +4823,7 @@ i32.const 2 i32.sub local.set $offset - i32.const 14812 + i32.const 15068 local.get $d1|10 i32.const 2 i32.shl @@ -4797,7 +4846,7 @@ i32.const 2 i32.sub local.set $offset - i32.const 14812 + i32.const 15068 local.get $num i32.const 2 i32.shl @@ -4844,7 +4893,7 @@ i32.const 1 i32.shl i32.add - i32.const 15232 + i32.const 15488 local.get $num i32.wrap_i64 i32.const 255 @@ -4866,7 +4915,7 @@ i32.and if local.get $buffer - i32.const 15232 + i32.const 15488 local.get $num i32.wrap_i64 i32.const 6 @@ -4989,7 +5038,7 @@ i32.const 1 i32.shl i32.add - i32.const 16288 + i32.const 16544 local.get $num local.get $mask i64.and @@ -5023,7 +5072,7 @@ i32.const 1 i32.shl i32.add - i32.const 16288 + i32.const 16544 local.get $num local.get $q local.get $base @@ -5044,95 +5093,16 @@ end end ) - (func $~lib/number/U32#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/utoa32 - return - ) (func $~lib/number/I32#toString (param $this i32) (param $radix i32) (result i32) local.get $this local.get $radix call $~lib/util/number/itoa32 return ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/string/String#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 1 - i32.shr_u - return - ) - (func $assembly/codec/ValOffset#set:value (param $this i32) (param $value i32) - local.get $this - local.get $value - i32.store - ) - (func $assembly/codec/ValOffset#set:offset (param $this i32) (param $offset i32) - local.get $this - local.get $offset - i32.store offset=4 - ) - (func $assembly/codec/ValOffset#get:offset (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/ValOffset#get:value (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/CodeAndMetadata#set:code (param $this i32) (param $code i32) - local.get $this - local.get $code - i32.store - local.get $this - local.get $code - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/CodeAndMetadata#set:metadata (param $this i32) (param $metadata i32) - local.get $this - local.get $metadata - i32.store offset=4 - local.get $this - local.get $metadata - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/CodeAndMetadata#get:code (param $this i32) (result i32) + (func $assembly/instructions/Instruction#get:namePtr (param $this i32) (result i32) local.get $this i32.load ) - (func $assembly/program/CodeAndMetadata#get:metadata (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) (func $~lib/number/U8#toString (param $this i32) (param $radix i32) (result i32) local.get $this i32.const 255 @@ -5141,57 +5111,7 @@ call $~lib/util/number/utoa32 return ) - (func $~lib/memory/memory.repeat (param $dst i32) (param $src i32) (param $srcLength i32) (param $count i32) - (local $index i32) - (local $total i32) - i32.const 0 - local.set $index - local.get $srcLength - local.get $count - i32.mul - local.set $total - loop $while-continue|0 - local.get $index - local.get $total - i32.lt_u - if - local.get $dst - local.get $index - i32.add - local.get $src - local.get $srcLength - memory.copy - local.get $index - local.get $srcLength - i32.add - local.set $index - br $while-continue|0 - end - end - ) - (func $assembly/program/Mask#set:bytesToSkip (param $this i32) (param $bytesToSkip i32) - local.get $this - local.get $bytesToSkip - i32.store - local.get $this - local.get $bytesToSkip - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Mask#get:bytesToSkip (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + (func $~lib/staticarray/StaticArray<~lib/string/String>#__uset (param $this i32) (param $index i32) (param $value i32) local.get $this local.get $index i32.const 2 @@ -5199,19 +5119,14 @@ i32.add local.get $value i32.store - i32.const 0 + i32.const 1 drop - ) - (func $assembly/program/JumpTable#set:jumps (param $this i32) (param $jumps i32) local.get $this - local.get $jumps - i32.store - local.get $this - local.get $jumps - i32.const 0 + local.get $value + i32.const 1 call $~lib/rt/itcms/__link ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + (func $~lib/staticarray/StaticArray<~lib/string/String>#get:length (param $this i32) (result i32) local.get $this i32.const 20 i32.sub @@ -5220,78 +5135,6 @@ i32.shr_u return ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - ) - (func $assembly/instructions/Instruction#get:isTerminating (param $this i32) (result i32) - local.get $this - i32.load8_u offset=16 - ) - (func $assembly/program/BasicBlocks#set:isStartOrEnd (param $this i32) (param $isStartOrEnd i32) - local.get $this - local.get $isStartOrEnd - i32.store - local.get $this - local.get $isStartOrEnd - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:code (param $this i32) (param $code i32) - local.get $this - local.get $code - i32.store - local.get $this - local.get $code - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:mask (param $this i32) (param $mask i32) - local.get $this - local.get $mask - i32.store offset=4 - local.get $this - local.get $mask - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:jumpTable (param $this i32) (param $jumpTable i32) - local.get $this - local.get $jumpTable - i32.store offset=8 - local.get $this - local.get $jumpTable - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:basicBlocks (param $this i32) (param $basicBlocks i32) - local.get $this - local.get $basicBlocks - i32.store offset=12 - local.get $this - local.get $basicBlocks - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#get:code (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/Program#get:mask (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/Instruction#get:namePtr (param $this i32) (result i32) - local.get $this - i32.load - ) (func $assembly/instructions/Instruction#get:kind (param $this i32) (result i32) local.get $this i32.load offset=4 @@ -5325,231 +5168,62 @@ local.get $this i32.load offset=4 ) - (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + (func $~lib/number/U32#toString (param $this i32) (param $radix i32) (result i32) local.get $this - local.get $length_ - i32.store offset=12 + local.get $radix + call $~lib/util/number/utoa32 + return ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) local.get $this - i32.load offset=4 + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 0 + i32.shr_u + return ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) local.get $this - i32.load offset=12 - ) - (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i64) (param $start i32) (param $end i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $start - i32.add - local.tee $5 - i32.const 0 - local.tee $6 - local.get $5 - local.get $6 - i32.gt_u - select - else - local.get $start - local.tee $7 - local.get $len - local.tee $8 - local.get $7 - local.get $8 - i32.lt_s - select - end - local.set $start - local.get $end + local.get $index i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $end - i32.add - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_u - select - else - local.get $end - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - end - local.set $end - i32.const 8 - i32.const 1 - i32.eq - drop + i32.shl + i32.add + local.get $value + i32.store8 i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 1 drop - local.get $value - i64.const 0 - i64.eq - local.get $value - i64.const -1 - i64.eq - i32.or + ) + (func $assembly/program-build/immBytes (param $dataLength i32) (param $required i32) (result i32) + (local $value1 f64) + (local $value2 f64) + local.get $dataLength + local.get $required + i32.lt_s if - local.get $start - local.get $end - i32.lt_s - if - local.get $ptr - local.get $start - i32.const 3 - i32.shl - i32.add - local.get $value - i32.wrap_i64 - local.get $end - local.get $start - i32.sub - i32.const 3 - i32.shl - memory.fill - end + i32.const 0 return end - loop $for-loop|0 - local.get $start - local.get $end - i32.lt_s - if - local.get $ptr - local.get $start - i32.const 3 - i32.shl - i32.add - local.get $value - i64.store - local.get $start - i32.const 1 - i32.add - local.set $start - br $for-loop|0 - end + block $~lib/math/NativeMath.min|inlined.4 (result f64) + f64.const 4 + local.set $value1 + local.get $dataLength + local.get $required + i32.sub + f64.convert_i32_s + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.4 end + i32.trunc_sat_f64_s + return ) - (func $assembly/api-generic/VmInput#set:registers (param $this i32) (param $registers i32) - local.get $this - local.get $registers - i32.store - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmInput#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store offset=4 - ) - (func $assembly/api-generic/VmInput#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/api-generic/VmInput#set:program (param $this i32) (param $program i32) - local.get $this - local.get $program - i32.store offset=16 - local.get $this - local.get $program - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmInput#set:pageMap (param $this i32) (param $pageMap i32) - local.get $this - local.get $pageMap - i32.store offset=20 - local.get $this - local.get $pageMap - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmInput#set:memory (param $this i32) (param $memory i32) - local.get $this - local.get $memory - i32.store offset=24 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmInput#get:program (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $assembly/api-generic/VmInput#get:registers (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/MemoryBuilder#set:pages (param $this i32) (param $pages i32) - local.get $this - local.get $pages - i32.store - local.get $this - local.get $pages - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/Arena#set:arenaBytes (param $this i32) (param $arenaBytes i32) - local.get $this - local.get $arenaBytes - i32.store offset=4 - ) - (func $assembly/memory-page/Arena#set:free (param $this i32) (param $free i32) - local.get $this - local.get $free - i32.store + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) local.get $this - local.get $free - i32.const 0 - call $~lib/rt/itcms/__link + local.get $length_ + i32.store offset=12 ) (func $~lib/arraybuffer/ArrayBuffer#get:byteLength (param $this i32) (result i32) local.get $this @@ -5558,172 +5232,33 @@ call $~lib/rt/common/OBJECT#get:rtSize return ) - (func $assembly/memory/MemoryBuilder#set:arena (param $this i32) (param $arena i32) - local.get $this - local.get $arena - i32.store offset=4 - local.get $this - local.get $arena - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-generic/VmInput#get:pageMap (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $assembly/api-generic/VmInput#get:memory (param $this i32) (result i32) - local.get $this - i32.load offset=24 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/api-generic/InitialPage#get:access (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/api-generic/InitialPage#get:address (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/api-generic/InitialPage#get:length (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/MemoryBuilder#get:pages (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/MemoryBuilder#get:arena (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/api-generic/InitialChunk#get:data (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/api-generic/InitialChunk#get:address (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/Memory#set:arena (param $this i32) (param $arena i32) - local.get $this - local.get $arena - i32.store offset=4 - local.get $this - local.get $arena - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#set:pages (param $this i32) (param $pages i32) - local.get $this - local.get $pages - i32.store offset=8 - local.get $this - local.get $pages - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/interpreter/Interpreter#set:program (param $this i32) (param $program i32) + (func $~lib/dataview/DataView#set:buffer (param $this i32) (param $buffer i32) local.get $this - local.get $program + local.get $buffer i32.store local.get $this - local.get $program + local.get $buffer i32.const 0 call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/Interpreter#set:registers (param $this i32) (param $registers i32) + (func $~lib/dataview/DataView#set:dataStart (param $this i32) (param $dataStart i32) local.get $this - local.get $registers + local.get $dataStart i32.store offset=4 - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/Interpreter#set:memory (param $this i32) (param $memory i32) + (func $~lib/dataview/DataView#set:byteLength (param $this i32) (param $byteLength i32) local.get $this - local.get $memory + local.get $byteLength i32.store offset=8 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/gas/GasCounterU64#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store - ) - (func $assembly/gas/gasCounter (param $gas i64) (result i32) - i32.const 0 - local.get $gas - call $assembly/gas/GasCounterU64#constructor - return - ) - (func $assembly/interpreter/Interpreter#set:gas (param $this i32) (param $gas i32) - local.get $this - local.get $gas - i32.store offset=12 - local.get $this - local.get $gas - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/interpreter/Interpreter#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store offset=16 - ) - (func $assembly/interpreter/Interpreter#set:status (param $this i32) (param $status i32) - local.get $this - local.get $status - i32.store offset=20 - ) - (func $assembly/interpreter/Interpreter#set:exitCode (param $this i32) (param $exitCode i32) - local.get $this - local.get $exitCode - i32.store offset=24 - ) - (func $assembly/interpreter/Interpreter#set:nextPc (param $this i32) (param $nextPc i32) - local.get $this - local.get $nextPc - i32.store offset=28 ) - (func $assembly/interpreter/Interpreter#set:useSbrkGas (param $this i32) (param $useSbrkGas i32) + (func $~lib/dataview/DataView#get:byteLength (param $this i32) (result i32) local.get $this - local.get $useSbrkGas - i32.store8 offset=32 + i32.load offset=8 ) - (func $assembly/api-generic/VmInput#get:pc (param $this i32) (result i32) + (func $~lib/dataview/DataView#get:dataStart (param $this i32) (result i32) local.get $this i32.load offset=4 ) - (func $assembly/interpreter/Interpreter#get:gas (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/api-generic/VmInput#get:gas (param $this i32) (result i64) - local.get $this - i64.load offset=8 - ) - (func $assembly/gas/GasCounter#set (param $this i32) (param $g i64) - unreachable - ) (func $~lib/util/number/decimalCount64High (param $value i64) (result i32) local.get $value i64.const 1000000000000000 @@ -5836,14 +5371,14 @@ i32.const 100 i32.rem_u local.set $c2 - i32.const 14812 + i32.const 15068 local.get $c1 i32.const 2 i32.shl i32.add i64.load32_u local.set $digits1 - i32.const 14812 + i32.const 15068 local.get $c2 i32.const 2 i32.shl @@ -5865,14 +5400,14 @@ i64.shl i64.or i64.store - i32.const 14812 + i32.const 15068 local.get $b1 i32.const 2 i32.shl i32.add i64.load32_u local.set $digits1 - i32.const 14812 + i32.const 15068 local.get $b2 i32.const 2 i32.shl @@ -5903,294 +5438,310 @@ local.get $offset call $~lib/util/number/utoa32_dec_lut ) - (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i64) (result i32) - (local $sign i32) - (local $dest i32) - (local $decimals i32) - (local $val32 i32) - (local $buffer|6 i32) - (local $num i32) - (local $offset i32) - (local $val64 i64) - (local $buffer|10 i32) - (local $num|11 i64) - (local $offset|12 i32) - i32.const 0 - local.set $sign - i32.const 0 - drop - local.get $buffer - local.get $sign - i32.const 1 - i32.shl - i32.add - local.set $dest - i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 0 - drop - local.get $value - i64.const 10 - i64.lt_u - if - local.get $buffer - local.get $value - i32.const 48 - i64.extend_i32_s - i64.or - i64.store16 - i32.const 1 - return - end - i32.const 0 - local.set $decimals - i32.const 8 - i32.const 4 - i32.le_u - drop - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - local.get $dest - local.set $buffer|6 - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|6 - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - local.set $val64 - local.get $val64 - call $~lib/util/number/decimalCount64High - local.set $decimals - local.get $dest - local.set $buffer|10 - local.get $val64 - local.set $num|11 - local.get $decimals - local.set $offset|12 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|10 - local.get $num|11 - local.get $offset|12 - call $~lib/util/number/utoa64_dec_lut - end - local.get $sign - local.get $decimals - i32.add - return - ) (func $~lib/number/U64#toString (param $this i64) (param $radix i32) (result i32) local.get $this local.get $radix call $~lib/util/number/utoa64 return ) - (func $~lib/array/Array<~lib/string/String>#get:dataStart (param $this i32) (result i32) + (func $assembly/codec/Decoder#set:source (param $this i32) (param $source i32) local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array<~lib/string/String>#get:length_ (param $this i32) (result i32) + local.get $source + i32.store local.get $this - i32.load offset=12 + local.get $source + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/Interpreter#get:status (param $this i32) (result i32) + (func $assembly/codec/Decoder#set:offset (param $this i32) (param $offset i32) local.get $this - i32.load offset=20 + local.get $offset + i32.store offset=4 ) - (func $assembly/interpreter/Interpreter#get:pc (param $this i32) (result i32) + (func $assembly/codec/Decoder#get:offset (param $this i32) (result i32) local.get $this - i32.load offset=16 + i32.load offset=4 ) - (func $assembly/interpreter/Interpreter#get:program (param $this i32) (result i32) + (func $assembly/codec/Decoder#get:source (param $this i32) (result i32) local.get $this i32.load ) - (func $assembly/interpreter/Interpreter#get:registers (param $this i32) (result i32) + (func $assembly/codec/ValOffset#set:value (param $this i32) (param $value i32) local.get $this - i32.load offset=4 + local.get $value + i32.store ) - (func $assembly/program/ResolvedArguments#set:a (param $this i32) (param $a i64) + (func $assembly/codec/ValOffset#set:offset (param $this i32) (param $offset i32) local.get $this - local.get $a - i64.store + local.get $offset + i32.store offset=4 ) - (func $assembly/program/ResolvedArguments#set:b (param $this i32) (param $b i64) + (func $assembly/codec/ValOffset#get:offset (param $this i32) (result i32) local.get $this - local.get $b - i64.store offset=8 + i32.load offset=4 ) - (func $assembly/program/ResolvedArguments#set:c (param $this i32) (param $c i64) + (func $assembly/codec/ValOffset#get:value (param $this i32) (result i32) local.get $this - local.get $c - i64.store offset=16 + i32.load ) - (func $assembly/program/ResolvedArguments#set:d (param $this i32) (param $d i64) + (func $assembly/program/CodeAndMetadata#set:code (param $this i32) (param $code i32) local.get $this - local.get $d - i64.store offset=24 + local.get $code + i32.store + local.get $this + local.get $code + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/program/ResolvedArguments#set:decoded (param $this i32) (param $decoded i32) + (func $assembly/program/CodeAndMetadata#set:metadata (param $this i32) (param $metadata i32) local.get $this - local.get $decoded - i32.store offset=32 + local.get $metadata + i32.store offset=4 local.get $this - local.get $decoded + local.get $metadata i32.const 0 call $~lib/rt/itcms/__link ) - (func $assembly/program/ResolvedArguments#get:a (param $this i32) (result i64) + (func $assembly/program/CodeAndMetadata#get:code (param $this i32) (result i32) local.get $this - i64.load + i32.load ) - (func $~lib/number/I64#toString (param $this i64) (param $radix i32) (result i32) + (func $assembly/program/Mask#set:bytesToSkip (param $this i32) (param $bytesToSkip i32) local.get $this - local.get $radix - call $~lib/util/number/itoa64 - return - ) - (func $assembly/program/ResolvedArguments#get:decoded (param $this i32) (result i32) + local.get $bytesToSkip + i32.store local.get $this - i32.load offset=32 + local.get $bytesToSkip + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/program/ResolvedArguments#get:b (param $this i32) (result i64) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) local.get $this - i64.load offset=8 + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop ) - (func $assembly/program/ResolvedArguments#get:c (param $this i32) (result i64) + (func $assembly/program/JumpTable#set:jumps (param $this i32) (param $jumps i32) local.get $this - i64.load offset=16 - ) - (func $assembly/program/ResolvedArguments#get:d (param $this i32) (result i64) + local.get $jumps + i32.store local.get $this - i64.load offset=24 + local.get $jumps + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/Interpreter#get:nextPc (param $this i32) (result i32) + (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) local.get $this - i32.load offset=28 + i32.const 20 + i32.sub + call $~lib/rt/common/OBJECT#get:rtSize + i32.const 2 + i32.shr_u + return ) - (func $assembly/instructions/Instruction#get:gas (param $this i32) (result i64) + (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) local.get $this - i64.load offset=8 - ) - (func $assembly/gas/GasCounter#sub (param $this i32) (param $g i64) (result i32) - unreachable + local.get $index + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + i32.const 0 + drop ) - (func $assembly/interpreter/Interpreter#get:useSbrkGas (param $this i32) (result i32) + (func $assembly/instructions/Instruction#get:isTerminating (param $this i32) (result i32) local.get $this - i32.load8_u offset=32 + i32.load8_u offset=16 ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ (param $this i32) (result i32) + (func $assembly/program/BasicBlocks#set:isStartOrEnd (param $this i32) (param $isStartOrEnd i32) local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart (param $this i32) (result i32) + local.get $isStartOrEnd + i32.store local.get $this - i32.load offset=4 + local.get $isStartOrEnd + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/Interpreter#get:memory (param $this i32) (result i32) + (func $assembly/program/Program#set:code (param $this i32) (param $code i32) local.get $this - i32.load offset=8 + local.get $code + i32.store + local.get $this + local.get $code + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/instructions/outcome/OutcomeData#get:outcome (param $this i32) (result i32) + (func $assembly/program/Program#set:mask (param $this i32) (param $mask i32) local.get $this - i32.load + local.get $mask + i32.store offset=4 + local.get $this + local.get $mask + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/program/Program#get:jumpTable (param $this i32) (result i32) + (func $assembly/program/Program#set:jumpTable (param $this i32) (param $jumpTable i32) local.get $this - i32.load offset=8 + local.get $jumpTable + i32.store offset=8 + local.get $this + local.get $jumpTable + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/instructions/outcome/OutcomeData#get:dJump (param $this i32) (result i32) + (func $assembly/program/Program#set:basicBlocks (param $this i32) (param $basicBlocks i32) local.get $this - i32.load offset=8 + local.get $basicBlocks + i32.store offset=12 + local.get $this + local.get $basicBlocks + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/DjumpResult#set:status (param $this i32) (param $status i32) + (func $assembly/memory/MemoryBuilder#set:pages (param $this i32) (param $pages i32) local.get $this - local.get $status + local.get $pages i32.store + local.get $this + local.get $pages + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/DjumpResult#set:newPc (param $this i32) (param $newPc i32) + (func $assembly/memory-page/Arena#set:arenaBytes (param $this i32) (param $arenaBytes i32) local.get $this - local.get $newPc + local.get $arenaBytes i32.store offset=4 ) - (func $assembly/program/JumpTable#get:jumps (param $this i32) (result i32) + (func $assembly/memory-page/Arena#set:free (param $this i32) (param $free i32) local.get $this - i32.load + local.get $free + i32.store + local.get $this + local.get $free + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/DjumpResult#get:status (param $this i32) (result i32) + (func $assembly/memory/MemoryBuilder#set:arena (param $this i32) (param $arena i32) local.get $this - i32.load + local.get $arena + i32.store offset=4 + local.get $this + local.get $arena + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/program/Program#get:basicBlocks (param $this i32) (result i32) + (func $assembly/spi/alignToSegmentSize (param $size i32) (result i32) + local.get $size + global.get $assembly/memory-page/SEGMENT_SIZE + i32.add + i32.const 1 + i32.sub + global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT + i32.shr_u + global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT + i32.shl + return + ) + (func $assembly/spi/alignToPageSize (param $size i32) (result i32) + local.get $size + global.get $assembly/memory-page/PAGE_SIZE + i32.add + i32.const 1 + i32.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shl + return + ) + (func $assembly/memory/MemoryBuilder#get:pages (param $this i32) (result i32) local.get $this - i32.load offset=12 + i32.load ) - (func $assembly/interpreter/DjumpResult#get:newPc (param $this i32) (result i32) + (func $assembly/memory/MemoryBuilder#get:arena (param $this i32) (result i32) local.get $this i32.load offset=4 ) - (func $assembly/interpreter/BranchResult#set:isOkay (param $this i32) (param $isOkay i32) + (func $assembly/memory/Memory#set:arena (param $this i32) (param $arena i32) local.get $this - local.get $isOkay - i32.store8 + local.get $arena + i32.store offset=4 + local.get $this + local.get $arena + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/BranchResult#set:newPc (param $this i32) (param $newPc i32) + (func $assembly/memory/Memory#set:pages (param $this i32) (param $pages i32) local.get $this - local.get $newPc - i32.store offset=4 + local.get $pages + i32.store offset=8 + local.get $this + local.get $pages + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/program/BasicBlocks#get:isStartOrEnd (param $this i32) (result i32) + (func $assembly/spi/StandardProgram#set:program (param $this i32) (param $program i32) local.get $this - i32.load + local.get $program + i32.store offset=16 + local.get $this + local.get $program + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/BranchResult#get:isOkay (param $this i32) (result i32) + (func $assembly/spi/StandardProgram#set:memory (param $this i32) (param $memory i32) local.get $this - i32.load8_u + local.get $memory + i32.store offset=20 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/interpreter/BranchResult#get:newPc (param $this i32) (result i32) + (func $assembly/spi/StandardProgram#set:registers (param $this i32) (param $registers i32) local.get $this - i32.load offset=4 + local.get $registers + i32.store offset=24 + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/instructions/outcome/OutcomeData#get:staticJump (param $this i32) (result i32) + (func $assembly/spi/StandardProgram#set:metadata (param $this i32) (param $metadata i32) local.get $this - i32.load offset=4 + local.get $metadata + i32.store + local.get $this + local.get $metadata + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/instructions/outcome/OutcomeData#get:result (param $this i32) (result i32) + (func $assembly/spi/StandardProgram#set:pc (param $this i32) (param $pc i32) local.get $this - i32.load offset=12 + local.get $pc + i32.store offset=4 ) - (func $assembly/instructions/outcome/OutcomeData#get:exitCode (param $this i32) (result i32) + (func $assembly/spi/StandardProgram#set:gas (param $this i32) (param $gas i64) local.get $this - i32.load offset=16 + local.get $gas + i64.store offset=8 ) - (func $assembly/api-generic/VmOutput#set:status (param $this i32) (param $status i32) + (func $assembly/interpreter/Interpreter#set:program (param $this i32) (param $program i32) local.get $this - local.get $status + local.get $program i32.store + local.get $this + local.get $program + i32.const 0 + call $~lib/rt/itcms/__link ) - (func $assembly/api-generic/VmOutput#set:registers (param $this i32) (param $registers i32) + (func $assembly/interpreter/Interpreter#set:registers (param $this i32) (param $registers i32) local.get $this local.get $registers i32.store offset=4 @@ -6199,34 +5750,84 @@ i32.const 0 call $~lib/rt/itcms/__link ) - (func $assembly/api-generic/VmOutput#set:pc (param $this i32) (param $pc i32) + (func $assembly/interpreter/Interpreter#set:memory (param $this i32) (param $memory i32) local.get $this - local.get $pc + local.get $memory i32.store offset=8 - ) - (func $assembly/api-generic/VmOutput#set:memory (param $this i32) (param $memory i32) local.get $this local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/gas/GasCounterU64#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store + ) + (func $assembly/gas/gasCounter (param $gas i64) (result i32) + i32.const 0 + local.get $gas + call $assembly/gas/GasCounterU64#constructor + return + ) + (func $assembly/interpreter/Interpreter#set:gas (param $this i32) (param $gas i32) + local.get $this + local.get $gas i32.store offset=12 local.get $this - local.get $memory + local.get $gas i32.const 0 call $~lib/rt/itcms/__link ) - (func $assembly/api-generic/VmOutput#set:gas (param $this i32) (param $gas i64) + (func $assembly/interpreter/Interpreter#set:pc (param $this i32) (param $pc i32) local.get $this - local.get $gas - i64.store offset=16 + local.get $pc + i32.store offset=16 ) - (func $assembly/api-generic/VmOutput#set:exitCode (param $this i32) (param $exitCode i32) + (func $assembly/interpreter/Interpreter#set:status (param $this i32) (param $status i32) + local.get $this + local.get $status + i32.store offset=20 + ) + (func $assembly/interpreter/Interpreter#set:exitCode (param $this i32) (param $exitCode i32) local.get $this local.get $exitCode i32.store offset=24 ) - (func $assembly/gas/GasCounter#get (param $this i32) (result i64) + (func $assembly/interpreter/Interpreter#set:nextPc (param $this i32) (param $nextPc i32) + local.get $this + local.get $nextPc + i32.store offset=28 + ) + (func $assembly/interpreter/Interpreter#set:useSbrkGas (param $this i32) (param $useSbrkGas i32) + local.get $this + local.get $useSbrkGas + i32.store8 offset=32 + ) + (func $assembly/spi/StandardProgram#get:program (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/spi/StandardProgram#get:registers (param $this i32) (result i32) + local.get $this + i32.load offset=24 + ) + (func $assembly/spi/StandardProgram#get:memory (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $assembly/interpreter/Interpreter#get:gas (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/gas/GasCounter#set (param $this i32) (param $g i64) unreachable ) - (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) + (func $assembly/interpreter/Interpreter#get:memory (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) local.get $this local.get $buffer i32.store @@ -6235,191 +5836,698 @@ i32.const 0 call $~lib/rt/itcms/__link ) - (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) + (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) local.get $this local.get $dataStart i32.store offset=4 ) - (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) + (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) local.get $this local.get $byteLength i32.store offset=8 ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) local.get $this local.get $length_ i32.store offset=12 ) - (func $assembly/api-generic/InitialChunk#set:address (param $this i32) (param $address i32) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/api-internal/InitialPage#set:address (param $this i32) (param $address i32) local.get $this local.get $address i32.store ) - (func $assembly/api-generic/InitialChunk#set:data (param $this i32) (param $data i32) + (func $assembly/api-internal/InitialPage#set:length (param $this i32) (param $length i32) local.get $this - local.get $data + local.get $length i32.store offset=4 + ) + (func $assembly/api-internal/InitialPage#set:access (param $this i32) (param $access i32) local.get $this - local.get $data - i32.const 0 - call $~lib/rt/itcms/__link + local.get $access + i32.store offset=8 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) local.get $this local.get $length_ i32.store offset=12 ) - (func $assembly/interpreter/Interpreter#get:exitCode (param $this i32) (result i32) + (func $assembly/api-internal/InitialChunk#set:address (param $this i32) (param $address i32) local.get $this - i32.load offset=24 + local.get $address + i32.store ) - (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) + (func $assembly/api-internal/InitialChunk#set:data (param $this i32) (param $data i32) local.get $this - local.get $buffer - i32.store + local.get $data + i32.store offset=4 local.get $this - local.get $buffer + local.get $data i32.const 0 call $~lib/rt/itcms/__link ) - (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) + (func $assembly/api-internal/InitialChunk#get:data (param $this i32) (result i32) local.get $this - local.get $dataStart - i32.store offset=4 + i32.load offset=4 ) - (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) local.get $this - local.get $byteLength - i32.store offset=8 + i32.load offset=12 ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) local.get $this local.get $length_ i32.store offset=12 ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + (func $assembly/api-internal/InitialPage#get:access (param $this i32) (result i32) local.get $this - i32.load offset=12 + i32.load offset=8 ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + (func $assembly/api-internal/InitialPage#get:address (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/api-internal/InitialPage#get:length (param $this i32) (result i32) local.get $this i32.load offset=4 ) - (func $assembly/api-generic/VmOutput#get:status (param $this i32) (result i32) + (func $assembly/api-internal/InitialChunk#get:address (param $this i32) (result i32) local.get $this i32.load ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) + (func $assembly/interpreter/Interpreter#get:status (param $this i32) (result i32) local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 0 - i32.shr_u - return + i32.load offset=20 ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) + (func $assembly/interpreter/Interpreter#get:nextPc (param $this i32) (result i32) local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - i32.const 0 - drop + i32.load offset=28 ) - (func $assembly/program-build/immBytes (param $dataLength i32) (param $required i32) (result i32) - (local $value1 f64) - (local $value2 f64) - local.get $dataLength - local.get $required - i32.lt_s - if - i32.const 0 - return - end - block $~lib/math/NativeMath.min|inlined.4 (result f64) - f64.const 4 - local.set $value1 - local.get $dataLength - local.get $required - i32.sub - f64.convert_i32_s - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.4 - end - i32.trunc_sat_f64_s - return + (func $assembly/interpreter/Interpreter#get:pc (param $this i32) (result i32) + local.get $this + i32.load offset=16 ) - (func $~lib/dataview/DataView#set:buffer (param $this i32) (param $buffer i32) + (func $assembly/interpreter/Interpreter#get:program (param $this i32) (result i32) local.get $this - local.get $buffer - i32.store + i32.load + ) + (func $assembly/instructions/Instruction#get:gas (param $this i32) (result i64) local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link + i64.load offset=8 ) - (func $~lib/dataview/DataView#set:dataStart (param $this i32) (param $dataStart i32) + (func $assembly/gas/GasCounter#sub (param $this i32) (param $g i64) (result i32) + unreachable + ) + (func $assembly/interpreter/Interpreter#get:useSbrkGas (param $this i32) (result i32) local.get $this - local.get $dataStart - i32.store offset=4 + i32.load8_u offset=32 ) - (func $~lib/dataview/DataView#set:byteLength (param $this i32) (param $byteLength i32) + (func $assembly/interpreter/Interpreter#get:registers (param $this i32) (result i32) local.get $this - local.get $byteLength - i32.store offset=8 + i32.load offset=4 ) - (func $~lib/dataview/DataView#get:byteLength (param $this i32) (result i32) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ (param $this i32) (result i32) local.get $this - i32.load offset=8 + i32.load offset=12 ) - (func $~lib/dataview/DataView#get:dataStart (param $this i32) (result i32) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart (param $this i32) (result i32) local.get $this i32.load offset=4 ) - (func $assembly/api-generic/InitialPage#set:address (param $this i32) (param $address i32) + (func $assembly/instructions/outcome/OutcomeData#get:outcome (param $this i32) (result i32) local.get $this - local.get $address + i32.load + ) + (func $assembly/program/Program#get:jumpTable (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/instructions/outcome/OutcomeData#get:dJump (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $assembly/interpreter/DjumpResult#set:status (param $this i32) (param $status i32) + local.get $this + local.get $status i32.store ) - (func $assembly/api-generic/InitialPage#set:length (param $this i32) (param $length i32) + (func $assembly/interpreter/DjumpResult#set:newPc (param $this i32) (param $newPc i32) local.get $this - local.get $length + local.get $newPc i32.store offset=4 ) - (func $assembly/api-generic/InitialPage#set:access (param $this i32) (param $access i32) + (func $assembly/program/JumpTable#get:jumps (param $this i32) (result i32) local.get $this - local.get $access - i32.store offset=8 + i32.load ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + (func $assembly/interpreter/DjumpResult#get:status (param $this i32) (result i32) local.get $this - local.get $length_ - i32.store offset=12 + i32.load ) - (func $~lib/rt/itcms/__pin (param $ptr i32) (result i32) - (local $obj i32) - local.get $ptr - if - local.get $ptr - i32.const 20 - i32.sub - local.set $obj - local.get $obj - call $~lib/rt/itcms/Object#get:color - i32.const 3 - i32.eq - if - i32.const 19920 - i32.const 352 - i32.const 338 - i32.const 7 - call $~lib/builtins/abort + (func $assembly/program/Program#get:basicBlocks (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/interpreter/DjumpResult#get:newPc (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/interpreter/BranchResult#set:isOkay (param $this i32) (param $isOkay i32) + local.get $this + local.get $isOkay + i32.store8 + ) + (func $assembly/interpreter/BranchResult#set:newPc (param $this i32) (param $newPc i32) + local.get $this + local.get $newPc + i32.store offset=4 + ) + (func $assembly/program/BasicBlocks#get:isStartOrEnd (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/interpreter/BranchResult#get:isOkay (param $this i32) (result i32) + local.get $this + i32.load8_u + ) + (func $assembly/interpreter/BranchResult#get:newPc (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/outcome/OutcomeData#get:staticJump (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/instructions/outcome/OutcomeData#get:result (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $assembly/instructions/outcome/OutcomeData#get:exitCode (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/interpreter/Interpreter#get:exitCode (param $this i32) (result i32) + local.get $this + i32.load offset=24 + ) + (func $assembly/gas/GasCounter#get (param $this i32) (result i64) + unreachable + ) + (func $assembly/program/CodeAndMetadata#get:metadata (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $"~lib/map/Map#set:buckets" (param $this i32) (param $buckets i32) + local.get $this + local.get $buckets + i32.store + local.get $this + local.get $buckets + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $"~lib/map/Map#set:bucketsMask" (param $this i32) (param $bucketsMask i32) + local.get $this + local.get $bucketsMask + i32.store offset=4 + ) + (func $"~lib/map/Map#set:entries" (param $this i32) (param $entries i32) + local.get $this + local.get $entries + i32.store offset=8 + local.get $this + local.get $entries + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $"~lib/map/Map#set:entriesCapacity" (param $this i32) (param $entriesCapacity i32) + local.get $this + local.get $entriesCapacity + i32.store offset=12 + ) + (func $"~lib/map/Map#set:entriesOffset" (param $this i32) (param $entriesOffset i32) + local.get $this + local.get $entriesOffset + i32.store offset=16 + ) + (func $"~lib/map/Map#set:entriesCount" (param $this i32) (param $entriesCount i32) + local.get $this + local.get $entriesCount + i32.store offset=20 + ) + (func $assembly/gas-costs/BlockGasCost#get:pc (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $"~lib/map/Map#get:buckets" (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $"~lib/map/Map#get:bucketsMask" (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $"~lib/map/MapEntry#get:taggedNext" (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#get:key" (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $"~lib/map/MapEntry#set:value" (param $this i32) (param $value i32) + local.get $this + local.get $value + i32.store offset=4 + ) + (func $"~lib/map/Map#get:entriesOffset" (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $"~lib/map/Map#get:entriesCapacity" (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $"~lib/map/Map#get:entriesCount" (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $"~lib/map/Map#get:entries" (param $this i32) (result i32) + local.get $this + i32.load offset=8 + ) + (func $"~lib/map/MapEntry#set:key" (param $this i32) (param $key i32) + local.get $this + local.get $key + i32.store + ) + (func $"~lib/map/MapEntry#get:value" (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $"~lib/map/MapEntry#set:taggedNext" (param $this i32) (param $taggedNext i32) + local.get $this + local.get $taggedNext + i32.store offset=8 + ) + (func $assembly/gas-costs/BlockGasCost#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store + ) + (func $assembly/gas-costs/BlockGasCost#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=8 + ) + (func $assembly/gas-costs/BlockGasCost#get:gas (param $this i32) (result i64) + local.get $this + i64.load offset=8 + ) + (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) + local.get $this + local.get $length_ + i32.store offset=12 + ) + (func $~lib/array/Array#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $assembly/spi/StandardProgram#get:metadata (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/memory/memory.repeat (param $dst i32) (param $src i32) (param $srcLength i32) (param $count i32) + (local $index i32) + (local $total i32) + i32.const 0 + local.set $index + local.get $srcLength + local.get $count + i32.mul + local.set $total + loop $while-continue|0 + local.get $index + local.get $total + i32.lt_u + if + local.get $dst + local.get $index + i32.add + local.get $src + local.get $srcLength + memory.copy + local.get $index + local.get $srcLength + i32.add + local.set $index + br $while-continue|0 + end + end + ) + (func $assembly/api-internal/VmInput#set:program (param $this i32) (param $program i32) + local.get $this + local.get $program + i32.store offset=16 + local.get $this + local.get $program + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-internal/VmInput#set:memory (param $this i32) (param $memory i32) + local.get $this + local.get $memory + i32.store offset=20 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-internal/VmInput#set:registers (param $this i32) (param $registers i32) + local.get $this + local.get $registers + i32.store offset=24 + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-internal/VmInput#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store + ) + (func $assembly/api-internal/VmInput#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=8 + ) + (func $assembly/api-internal/VmInput#get:program (param $this i32) (result i32) + local.get $this + i32.load offset=16 + ) + (func $assembly/api-internal/VmInput#get:registers (param $this i32) (result i32) + local.get $this + i32.load offset=24 + ) + (func $assembly/api-internal/VmInput#get:memory (param $this i32) (result i32) + local.get $this + i32.load offset=20 + ) + (func $assembly/api-internal/VmInput#get:pc (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $assembly/api-internal/VmInput#get:gas (param $this i32) (result i64) + local.get $this + i64.load offset=8 + ) + (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i64) (result i32) + (local $sign i32) + (local $dest i32) + (local $decimals i32) + (local $val32 i32) + (local $buffer|6 i32) + (local $num i32) + (local $offset i32) + (local $val64 i64) + (local $buffer|10 i32) + (local $num|11 i64) + (local $offset|12 i32) + i32.const 0 + local.set $sign + i32.const 0 + drop + local.get $buffer + local.get $sign + i32.const 1 + i32.shl + i32.add + local.set $dest + i32.const 0 + i32.const 1 + i32.le_s + drop + i32.const 0 + drop + local.get $value + i64.const 10 + i64.lt_u + if + local.get $buffer + local.get $value + i32.const 48 + i64.extend_i32_s + i64.or + i64.store16 + i32.const 1 + return + end + i32.const 0 + local.set $decimals + i32.const 8 + i32.const 4 + i32.le_u + drop + local.get $value + global.get $~lib/builtins/u32.MAX_VALUE + i64.extend_i32_u + i64.le_u + if + local.get $value + i32.wrap_i64 + local.set $val32 + local.get $val32 + call $~lib/util/number/decimalCount32 + local.set $decimals + local.get $dest + local.set $buffer|6 + local.get $val32 + local.set $num + local.get $decimals + local.set $offset + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|6 + local.get $num + local.get $offset + call $~lib/util/number/utoa32_dec_lut + else + local.get $value + local.set $val64 + local.get $val64 + call $~lib/util/number/decimalCount64High + local.set $decimals + local.get $dest + local.set $buffer|10 + local.get $val64 + local.set $num|11 + local.get $decimals + local.set $offset|12 + i32.const 0 + i32.const 1 + i32.ge_s + drop + local.get $buffer|10 + local.get $num|11 + local.get $offset|12 + call $~lib/util/number/utoa64_dec_lut + end + local.get $sign + local.get $decimals + i32.add + return + ) + (func $~lib/array/Array<~lib/string/String>#get:dataStart (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/array/Array<~lib/string/String>#get:length_ (param $this i32) (result i32) + local.get $this + i32.load offset=12 + ) + (func $~lib/number/I64#toString (param $this i64) (param $radix i32) (result i32) + local.get $this + local.get $radix + call $~lib/util/number/itoa64 + return + ) + (func $assembly/program/ResolvedArguments#set:a (param $this i32) (param $a i64) + local.get $this + local.get $a + i64.store + ) + (func $assembly/program/ResolvedArguments#set:b (param $this i32) (param $b i64) + local.get $this + local.get $b + i64.store offset=8 + ) + (func $assembly/program/ResolvedArguments#set:c (param $this i32) (param $c i64) + local.get $this + local.get $c + i64.store offset=16 + ) + (func $assembly/program/ResolvedArguments#set:d (param $this i32) (param $d i64) + local.get $this + local.get $d + i64.store offset=24 + ) + (func $assembly/program/ResolvedArguments#set:decoded (param $this i32) (param $decoded i32) + local.get $this + local.get $decoded + i32.store offset=32 + local.get $this + local.get $decoded + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/program/ResolvedArguments#get:a (param $this i32) (result i64) + local.get $this + i64.load + ) + (func $assembly/program/ResolvedArguments#get:decoded (param $this i32) (result i32) + local.get $this + i32.load offset=32 + ) + (func $assembly/program/ResolvedArguments#get:b (param $this i32) (result i64) + local.get $this + i64.load offset=8 + ) + (func $assembly/program/ResolvedArguments#get:c (param $this i32) (result i64) + local.get $this + i64.load offset=16 + ) + (func $assembly/program/ResolvedArguments#get:d (param $this i32) (result i64) + local.get $this + i64.load offset=24 + ) + (func $assembly/api-internal/VmOutput#set:status (param $this i32) (param $status i32) + local.get $this + local.get $status + i32.store + ) + (func $assembly/api-internal/VmOutput#set:registers (param $this i32) (param $registers i32) + local.get $this + local.get $registers + i32.store offset=4 + local.get $this + local.get $registers + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-internal/VmOutput#set:pc (param $this i32) (param $pc i32) + local.get $this + local.get $pc + i32.store offset=8 + ) + (func $assembly/api-internal/VmOutput#set:memory (param $this i32) (param $memory i32) + local.get $this + local.get $memory + i32.store offset=12 + local.get $this + local.get $memory + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $assembly/api-internal/VmOutput#set:gas (param $this i32) (param $gas i64) + local.get $this + local.get $gas + i64.store offset=16 + ) + (func $assembly/api-internal/VmOutput#set:exitCode (param $this i32) (param $exitCode i32) + local.get $this + local.get $exitCode + i32.store offset=24 + ) + (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) + local.get $this + local.get $buffer + i32.store + local.get $this + local.get $buffer + i32.const 0 + call $~lib/rt/itcms/__link + ) + (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) + local.get $this + local.get $dataStart + i32.store offset=4 + ) + (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) + local.get $this + local.get $byteLength + i32.store offset=8 + ) + (func $~lib/rt/itcms/__pin (param $ptr i32) (result i32) + (local $obj i32) + local.get $ptr + if + local.get $ptr + i32.const 20 + i32.sub + local.set $obj + local.get $obj + call $~lib/rt/itcms/Object#get:color + i32.const 3 + i32.eq + if + i32.const 20368 + i32.const 352 + i32.const 338 + i32.const 7 + call $~lib/builtins/abort unreachable end local.get $obj @@ -6448,7 +6556,7 @@ i32.const 3 i32.ne if - i32.const 19984 + i32.const 20432 i32.const 352 i32.const 352 i32.const 5 @@ -6530,7 +6638,7 @@ i32.load local.set $2 local.get $2 - i32.const 51 + i32.const 46 i32.eq br_if $case0 br $default @@ -6552,7 +6660,7 @@ i32.load local.set $2 local.get $2 - i32.const 51 + i32.const 46 i32.eq br_if $case0 br $default @@ -6574,7 +6682,7 @@ i32.load local.set $1 local.get $1 - i32.const 51 + i32.const 46 i32.eq br_if $case0 br $default @@ -6593,10 +6701,10 @@ i32.const 8176 local.get $0 call $~lib/rt/itcms/__visit - i32.const 13120 + i32.const 11424 local.get $0 call $~lib/rt/itcms/__visit - i32.const 16800 + i32.const 14704 local.get $0 call $~lib/rt/itcms/__visit i32.const 9376 @@ -6605,75 +6713,75 @@ i32.const 288 local.get $0 call $~lib/rt/itcms/__visit - i32.const 19920 + i32.const 20368 local.get $0 call $~lib/rt/itcms/__visit - i32.const 19984 + i32.const 20432 local.get $0 call $~lib/rt/itcms/__visit - i32.const 15232 + i32.const 15488 local.get $0 call $~lib/rt/itcms/__visit - i32.const 16288 + i32.const 16544 local.get $0 call $~lib/rt/itcms/__visit - global.get $assembly/api/interpreter + global.get $assembly/api-debugger/interpreter local.tee $1 if local.get $1 local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/arguments/RELEVANT_ARGS + global.get $assembly/codec/MASKS local.tee $1 if local.get $1 local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/arguments/REQUIRED_BYTES + global.get $assembly/memory/NO_PAGE_FAULT local.tee $1 if local.get $1 local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/arguments/DECODERS + global.get $assembly/memory/EMPTY_UINT8ARRAY local.tee $1 if local.get $1 local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/instructions/INSTRUCTIONS + global.get $assembly/memory/EMPTY_PAGE local.tee $1 if local.get $1 local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/memory/NO_PAGE_FAULT + global.get $assembly/arguments/RELEVANT_ARGS local.tee $1 if local.get $1 local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/memory/EMPTY_UINT8ARRAY + global.get $assembly/arguments/REQUIRED_BYTES local.tee $1 if local.get $1 local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/memory/EMPTY_PAGE + global.get $assembly/arguments/DECODERS local.tee $1 if local.get $1 local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/codec/MASKS + global.get $assembly/instructions/INSTRUCTIONS local.tee $1 if local.get $1 @@ -6995,30 +7103,6 @@ local.get $1 call $~lib/rt/itcms/__visit ) - (func $assembly/program/CodeAndMetadata~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/codec/Decoder~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) (func $~lib/staticarray/StaticArray<~lib/string/String>#__visit (param $this i32) (param $cookie i32) (local $cur i32) (local $end i32) @@ -7064,18 +7148,6 @@ local.get $1 call $~lib/staticarray/StaticArray<~lib/string/String>#__visit ) - (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit - ) (func $~lib/array/Array#get:buffer (param $this i32) (result i32) local.get $this i32.load @@ -7088,55 +7160,63 @@ local.get $1 call $~lib/array/Array#__visit ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + (func $~lib/dataview/DataView~visit (param $0 i32) (param $1 i32) + (local $2 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 + i32.load local.get $1 - call $~lib/array/Array#__visit + call $~lib/rt/itcms/__visit ) - (func $assembly/api-generic/VmOutput~visit (param $0 i32) (param $1 i32) + (func $assembly/program/CodeAndMetadata~visit (param $0 i32) (param $1 i32) (local $2 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 - i32.load offset=4 + i32.load local.get $1 call $~lib/rt/itcms/__visit local.get $0 - i32.load offset=12 + i32.load offset=4 local.get $1 call $~lib/rt/itcms/__visit ) - (func $assembly/api-generic/InitialChunk~visit (param $0 i32) (param $1 i32) + (func $assembly/codec/Decoder~visit (param $0 i32) (param $1 i32) (local $2 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 - i32.load offset=4 + i32.load local.get $1 call $~lib/rt/itcms/__visit ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + (func $assembly/spi/StandardProgram~visit (param $0 i32) (param $1 i32) + (local $2 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 + i32.load + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=16 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=20 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=24 local.get $1 - call $~lib/array/Array#__visit + call $~lib/rt/itcms/__visit ) - (func $assembly/api-generic/VmInput~visit (param $0 i32) (param $1 i32) + (func $assembly/memory/MemoryBuilder~visit (param $0 i32) (param $1 i32) (local $2 i32) local.get $0 local.get $1 @@ -7146,315 +7226,402 @@ local.get $1 call $~lib/rt/itcms/__visit local.get $0 - i32.load offset=16 + i32.load offset=4 local.get $1 call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) local.get $0 - i32.load offset=20 local.get $1 - call $~lib/rt/itcms/__visit + call $~lib/object/Object~visit local.get $0 - i32.load offset=24 local.get $1 - call $~lib/rt/itcms/__visit + call $~lib/array/Array#__visit ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) local.get $this i32.load ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 local.get $1 - call $~lib/array/Array#__visit + call $~lib/array/Array#__visit ) - (func $assembly/memory/MemoryBuilder~visit (param $0 i32) (param $1 i32) + (func $assembly/api-internal/InitialChunk~visit (param $0 i32) (param $1 i32) (local $2 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 - i32.load + i32.load offset=4 local.get $1 call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) local.get $0 - i32.load offset=4 local.get $1 - call $~lib/rt/itcms/__visit + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit ) - (func $~lib/array/Array<~lib/string/String>#get:buffer (param $this i32) (result i32) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) local.get $this i32.load ) - (func $~lib/array/Array<~lib/string/String>~visit (param $0 i32) (param $1 i32) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 local.get $1 - call $~lib/array/Array<~lib/string/String>#__visit + call $~lib/array/Array#__visit ) - (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env (param $this i32) (result i32) + (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + local.get $this + i32.load + ) + (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/array/Array#__visit + ) + (func $"~lib/map/Map~visit" (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $"~lib/map/Map#__visit" + ) + (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env (param $this i32) (result i32) local.get $this i32.load offset=4 ) - (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) + (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 local.get $1 - call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit + call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit ) - (func $assembly/program/ResolvedArguments~visit (param $0 i32) (param $1 i32) + (func $assembly/api-internal/VmOutput~visit (param $0 i32) (param $1 i32) (local $2 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 - i32.load offset=32 + i32.load offset=4 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 local.get $1 call $~lib/rt/itcms/__visit ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) + (func $assembly/api-internal/VmInput~visit (param $0 i32) (param $1 i32) + (local $2 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + i32.load offset=16 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=20 + local.get $1 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=24 + local.get $1 + call $~lib/rt/itcms/__visit + ) + (func $~lib/array/Array<~lib/string/String>#get:buffer (param $this i32) (result i32) local.get $this i32.load ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) + (func $~lib/array/Array<~lib/string/String>~visit (param $0 i32) (param $1 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 local.get $1 - call $~lib/array/Array#__visit + call $~lib/array/Array<~lib/string/String>#__visit ) - (func $~lib/dataview/DataView~visit (param $0 i32) (param $1 i32) + (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env (param $this i32) (result i32) + local.get $this + i32.load offset=4 + ) + (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) + local.get $0 + local.get $1 + call $~lib/object/Object~visit + local.get $0 + local.get $1 + call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit + ) + (func $assembly/program/ResolvedArguments~visit (param $0 i32) (param $1 i32) (local $2 i32) local.get $0 local.get $1 call $~lib/object/Object~visit local.get $0 - i32.load + i32.load offset=32 local.get $1 call $~lib/rt/itcms/__visit ) (func $~lib/rt/__visit_members (param $0 i32) (param $1 i32) block $invalid - block $~lib/dataview/DataView - block $~lib/staticarray/StaticArray - block $~lib/array/Array - block $assembly/interpreter/BranchResult - block $assembly/interpreter/DjumpResult - block $assembly/program/ResolvedArguments - block $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> - block $~lib/array/Array<~lib/string/String> - block $assembly/gas/GasCounterU64 - block $assembly/memory/MemoryBuilder - block $~lib/array/Array - block $assembly/api-generic/InitialPage - block $assembly/api-generic/VmInput - block $~lib/array/Array - block $assembly/api-generic/InitialChunk - block $assembly/api-generic/VmOutput - block $~lib/array/Array - block $~lib/array/Array - block $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> - block $assembly/codec/ValOffset - block $~lib/staticarray/StaticArray<~lib/string/String> + block $assembly/program/ResolvedArguments + block $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> + block $~lib/array/Array<~lib/string/String> + block $assembly/api-internal/VmInput + block $assembly/api-internal/VmOutput + block $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> + block $"~lib/map/Map" + block $~lib/array/Array + block $~lib/array/Array + block $assembly/gas-costs/BlockGasCost + block $assembly/interpreter/BranchResult + block $assembly/interpreter/DjumpResult + block $~lib/array/Array + block $assembly/api-internal/InitialChunk + block $~lib/array/Array + block $assembly/api-internal/InitialPage + block $~lib/array/Array + block $assembly/gas/GasCounterU64 + block $assembly/memory/MemoryBuilder + block $assembly/spi/StandardProgram + block $assembly/codec/ValOffset block $assembly/codec/Decoder block $assembly/program/CodeAndMetadata - block $assembly/gas/GasCounter - block $~lib/staticarray/StaticArray - block $assembly/program/BasicBlocks - block $assembly/program/JumpTable - block $~lib/staticarray/StaticArray - block $assembly/program/Mask - block $assembly/program/Program - block $assembly/interpreter/Interpreter - block $~lib/function/Function<%28u8%29=>u8> - block $~lib/array/Array - block $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> - block $assembly/memory/PageData - block $assembly/memory/Chunks - block $~lib/staticarray/StaticArray - block $assembly/memory/ChunkBytes - block $assembly/memory/Result - block $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> - block $assembly/instructions/outcome/OutcomeData - block $"~lib/map/Map" - block $~lib/array/Array - block $assembly/memory-page/Arena - block $assembly/memory/Memory - block $~lib/staticarray/StaticArray - block $assembly/memory-page/RawPage - block $assembly/memory-page/Page - block $assembly/memory/MaybePageFault - block $~lib/array/Array - block $assembly/arguments/Nibbles - block $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> - block $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> - block $assembly/arguments/Args - block $~lib/typedarray/Uint8Array - block $~lib/array/Array - block $~lib/arraybuffer/ArrayBufferView - block $~lib/string/String - block $~lib/arraybuffer/ArrayBuffer - block $~lib/object/Object + block $~lib/dataview/DataView + block $~lib/staticarray/StaticArray + block $~lib/array/Array + block $~lib/staticarray/StaticArray<~lib/string/String> + block $assembly/gas/GasCounter + block $~lib/staticarray/StaticArray + block $assembly/program/BasicBlocks + block $assembly/program/JumpTable + block $~lib/staticarray/StaticArray + block $assembly/program/Mask + block $assembly/program/Program + block $assembly/interpreter/Interpreter + block $~lib/function/Function<%28u8%29=>u8> + block $~lib/array/Array + block $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> + block $assembly/memory/PageData + block $assembly/memory/Chunks + block $~lib/staticarray/StaticArray + block $assembly/memory/ChunkBytes + block $assembly/memory/Result + block $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> + block $assembly/instructions/outcome/OutcomeData + block $"~lib/map/Map" + block $~lib/array/Array + block $assembly/memory-page/Arena + block $assembly/memory/Memory + block $~lib/staticarray/StaticArray + block $assembly/memory-page/RawPage + block $assembly/memory-page/Page + block $assembly/memory/MaybePageFault + block $~lib/array/Array + block $assembly/arguments/Nibbles + block $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> + block $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> + block $assembly/arguments/Args + block $~lib/typedarray/Uint8Array + block $~lib/array/Array + block $~lib/arraybuffer/ArrayBufferView + block $~lib/string/String + block $~lib/arraybuffer/ArrayBuffer + block $~lib/object/Object + local.get $0 + i32.const 8 + i32.sub + i32.load + br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $~lib/arraybuffer/ArrayBufferView $~lib/array/Array $~lib/typedarray/Uint8Array $assembly/arguments/Args $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $assembly/arguments/Nibbles $~lib/array/Array $assembly/memory/MaybePageFault $assembly/memory-page/Page $assembly/memory-page/RawPage $~lib/staticarray/StaticArray $assembly/memory/Memory $assembly/memory-page/Arena $~lib/array/Array $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $assembly/memory/Result $assembly/memory/ChunkBytes $~lib/staticarray/StaticArray $assembly/memory/Chunks $assembly/memory/PageData $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $~lib/array/Array $~lib/function/Function<%28u8%29=>u8> $assembly/interpreter/Interpreter $assembly/program/Program $assembly/program/Mask $~lib/staticarray/StaticArray $assembly/program/JumpTable $assembly/program/BasicBlocks $~lib/staticarray/StaticArray $assembly/gas/GasCounter $~lib/staticarray/StaticArray<~lib/string/String> $~lib/array/Array $~lib/staticarray/StaticArray $~lib/dataview/DataView $assembly/program/CodeAndMetadata $assembly/codec/Decoder $assembly/codec/ValOffset $assembly/spi/StandardProgram $assembly/memory/MemoryBuilder $assembly/gas/GasCounterU64 $~lib/array/Array $assembly/api-internal/InitialPage $~lib/array/Array $assembly/api-internal/InitialChunk $~lib/array/Array $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $assembly/gas-costs/BlockGasCost $~lib/array/Array $~lib/array/Array $"~lib/map/Map" $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> $assembly/api-internal/VmOutput $assembly/api-internal/VmInput $~lib/array/Array<~lib/string/String> $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> $assembly/program/ResolvedArguments $invalid + end + return + end + return + end + return + end local.get $0 - i32.const 8 - i32.sub - i32.load - br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $~lib/arraybuffer/ArrayBufferView $~lib/array/Array $~lib/typedarray/Uint8Array $assembly/arguments/Args $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $assembly/arguments/Nibbles $~lib/array/Array $assembly/memory/MaybePageFault $assembly/memory-page/Page $assembly/memory-page/RawPage $~lib/staticarray/StaticArray $assembly/memory/Memory $assembly/memory-page/Arena $~lib/array/Array $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $assembly/memory/Result $assembly/memory/ChunkBytes $~lib/staticarray/StaticArray $assembly/memory/Chunks $assembly/memory/PageData $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $~lib/array/Array $~lib/function/Function<%28u8%29=>u8> $assembly/interpreter/Interpreter $assembly/program/Program $assembly/program/Mask $~lib/staticarray/StaticArray $assembly/program/JumpTable $assembly/program/BasicBlocks $~lib/staticarray/StaticArray $assembly/gas/GasCounter $assembly/program/CodeAndMetadata $assembly/codec/Decoder $~lib/staticarray/StaticArray<~lib/string/String> $assembly/codec/ValOffset $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> $~lib/array/Array $~lib/array/Array $assembly/api-generic/VmOutput $assembly/api-generic/InitialChunk $~lib/array/Array $assembly/api-generic/VmInput $assembly/api-generic/InitialPage $~lib/array/Array $assembly/memory/MemoryBuilder $assembly/gas/GasCounterU64 $~lib/array/Array<~lib/string/String> $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> $assembly/program/ResolvedArguments $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $~lib/array/Array $~lib/staticarray/StaticArray $~lib/dataview/DataView $invalid + local.get $1 + call $~lib/arraybuffer/ArrayBufferView~visit + return end + local.get $0 + local.get $1 + call $~lib/array/Array~visit return end + local.get $0 + local.get $1 + call $~lib/typedarray/Uint8Array~visit return end return end local.get $0 local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit return end local.get $0 local.get $1 - call $~lib/array/Array~visit + call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit return end - local.get $0 - local.get $1 - call $~lib/typedarray/Uint8Array~visit return end + local.get $0 + local.get $1 + call $~lib/array/Array~visit return end - local.get $0 - local.get $1 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit return end local.get $0 local.get $1 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit + call $assembly/memory-page/Page~visit return end + local.get $0 + local.get $1 + call $assembly/memory-page/RawPage~visit return end - local.get $0 - local.get $1 - call $~lib/array/Array~visit return end + local.get $0 + local.get $1 + call $assembly/memory/Memory~visit return end local.get $0 local.get $1 - call $assembly/memory-page/Page~visit + call $assembly/memory-page/Arena~visit return end local.get $0 local.get $1 - call $assembly/memory-page/RawPage~visit + call $~lib/array/Array~visit return end + local.get $0 + local.get $1 + call $"~lib/map/Map~visit" return end - local.get $0 - local.get $1 - call $assembly/memory/Memory~visit return end local.get $0 local.get $1 - call $assembly/memory-page/Arena~visit + call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit return end local.get $0 local.get $1 - call $~lib/array/Array~visit + call $assembly/memory/Result~visit return end local.get $0 local.get $1 - call $"~lib/map/Map~visit" + call $assembly/memory/ChunkBytes~visit return end return end local.get $0 local.get $1 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit + call $assembly/memory/Chunks~visit return end local.get $0 local.get $1 - call $assembly/memory/Result~visit + call $assembly/memory/PageData~visit return end local.get $0 local.get $1 - call $assembly/memory/ChunkBytes~visit + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit return end + local.get $0 + local.get $1 + call $~lib/array/Array~visit return end local.get $0 local.get $1 - call $assembly/memory/Chunks~visit + call $~lib/function/Function<%28u8%29=>u8>~visit return end local.get $0 local.get $1 - call $assembly/memory/PageData~visit + call $assembly/interpreter/Interpreter~visit return end local.get $0 local.get $1 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit + call $assembly/program/Program~visit return end local.get $0 local.get $1 - call $~lib/array/Array~visit + call $assembly/program/Mask~visit return end - local.get $0 - local.get $1 - call $~lib/function/Function<%28u8%29=>u8>~visit return end local.get $0 local.get $1 - call $assembly/interpreter/Interpreter~visit + call $assembly/program/JumpTable~visit return end local.get $0 local.get $1 - call $assembly/program/Program~visit + call $assembly/program/BasicBlocks~visit return end - local.get $0 - local.get $1 - call $assembly/program/Mask~visit return end return end local.get $0 local.get $1 - call $assembly/program/JumpTable~visit + call $~lib/staticarray/StaticArray<~lib/string/String>~visit return end local.get $0 local.get $1 - call $assembly/program/BasicBlocks~visit + call $~lib/array/Array~visit return end return end + local.get $0 + local.get $1 + call $~lib/dataview/DataView~visit return end local.get $0 @@ -7467,91 +7634,91 @@ call $assembly/codec/Decoder~visit return end - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray<~lib/string/String>~visit return end + local.get $0 + local.get $1 + call $assembly/spi/StandardProgram~visit return end local.get $0 local.get $1 - call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit + call $assembly/memory/MemoryBuilder~visit return end - local.get $0 - local.get $1 - call $~lib/array/Array~visit return end local.get $0 local.get $1 - call $~lib/array/Array~visit + call $~lib/array/Array~visit return end - local.get $0 - local.get $1 - call $assembly/api-generic/VmOutput~visit return end local.get $0 local.get $1 - call $assembly/api-generic/InitialChunk~visit + call $~lib/array/Array~visit return end local.get $0 local.get $1 - call $~lib/array/Array~visit + call $assembly/api-internal/InitialChunk~visit return end local.get $0 local.get $1 - call $assembly/api-generic/VmInput~visit + call $~lib/array/Array~visit return end return end - local.get $0 - local.get $1 - call $~lib/array/Array~visit return end - local.get $0 - local.get $1 - call $assembly/memory/MemoryBuilder~visit return end + local.get $0 + local.get $1 + call $~lib/array/Array~visit return end local.get $0 local.get $1 - call $~lib/array/Array<~lib/string/String>~visit + call $~lib/array/Array~visit return end local.get $0 local.get $1 - call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit + call $"~lib/map/Map~visit" return end local.get $0 local.get $1 - call $assembly/program/ResolvedArguments~visit + call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit return end + local.get $0 + local.get $1 + call $assembly/api-internal/VmOutput~visit return end + local.get $0 + local.get $1 + call $assembly/api-internal/VmInput~visit return end local.get $0 local.get $1 - call $~lib/array/Array~visit + call $~lib/array/Array<~lib/string/String>~visit return end + local.get $0 + local.get $1 + call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit return end local.get $0 local.get $1 - call $~lib/dataview/DataView~visit + call $assembly/program/ResolvedArguments~visit return end unreachable @@ -7568,8 +7735,8 @@ global.get $~lib/memory/__data_end i32.lt_s if - i32.const 53072 - i32.const 53120 + i32.const 53536 + i32.const 53584 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14757,7 +14924,7 @@ else i32.const 9488 i32.const 9616 - i32.const 42 + i32.const 46 i32.const 12 call $~lib/builtins/abort unreachable @@ -21197,10 +21364,11 @@ local.get $5 return ) - (func $start:assembly/instructions/mov~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) + (func $assembly/instructions/outcome/status (param $result i32) (result i32) + (local $r i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -21209,50 +21377,37 @@ i64.store global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r i32.store - local.get $3 - local.get $args - local.set $3 + local.get $r + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $2 i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $2 i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 + local.get $2 + local.get $result + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $2 return ) - (func $start:assembly/instructions/mov~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) + (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) + (local $r i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -21261,197 +21416,185 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $registers - local.set $3 global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r i32.store - local.get $3 - local.get $args - local.set $3 + local.get $r + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $2 i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Result.HOST + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $id + call $assembly/instructions/outcome/OutcomeData#set:exitCode + local.get $r + local.set $2 global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $2 return ) - (func $start:assembly/instructions/mov~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 0 i32.store - local.get $3 local.get $args local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 + i32.store local.get $3 call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok + call $assembly/instructions/outcome/hostCall local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer local.get $3 + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 return ) - (func $start:assembly/instructions/mov~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $~lib/array/Array#pop (param $this i32) (result i32) + (local $len i32) + (local $val i32) (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 i32.store local.get $3 - local.get $args + call $~lib/array/Array#get:length_ + local.set $len + local.get $len + i32.const 1 + i32.lt_s + if + i32.const 11424 + i32.const 8128 + i32.const 271 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $len + i32.const 1 + i32.sub + local.tee $len + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $val i32.store offset=4 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok + i32.store + local.get $3 + local.get $len + call $~lib/array/Array#set:length_ + local.get $val local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer local.get $3 return ) - (func $start:assembly/instructions/mov~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $~lib/console/console.log (param $message i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $message + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/bindings/dom/console.log + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory-page/Arena#acquire (param $this i32) (result i32) + (local $allocatedMemory i32) + (local $data i32) (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 12 @@ -21464,249 +21607,115 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $registers + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store + i32.store offset=4 local.get $3 - local.get $args + call $assembly/memory-page/Arena#get:free local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 + i32.store local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne + call $~lib/array/Array#get:length + i32.const 0 + i32.gt_s if - local.get $registers + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store + i32.store offset=4 local.get $3 - local.get $args + call $assembly/memory-page/Arena#get:free local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 + i32.store local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers + call $~lib/array/Array#pop local.set $3 global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set + return end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 i32.store local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args + call $assembly/memory-page/Arena#get:extraPageIndex + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.set $allocatedMemory + local.get $allocatedMemory + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer + i32.store local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + call $assembly/memory-page/Arena#get:arenaBytes + i32.eq + if + i32.const 11472 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/console/console.log + end global.get $~lib/memory/__stack_pointer - i32.const 0 + local.get $allocatedMemory + global.get $assembly/memory-page/ALLOCATE_EAGERLY + i32.lt_u + if (result i32) + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + else + i32.const 0 + end + local.tee $data i32.store offset=8 - local.get $regs + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 i32.store local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $regs + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 i32.store offset=4 local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 + call $assembly/memory-page/Arena#get:extraPageIndex + i32.const 1 i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer + call $assembly/memory-page/Arena#set:extraPageIndex i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 i32.store offset=4 local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $args + call $assembly/memory-page/Arena#get:extraPageIndex + local.get $data local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 + i32.store local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok + call $assembly/memory-page/RawPage#constructor local.set $3 global.get $~lib/memory/__stack_pointer i32.const 12 @@ -21715,10 +21724,22 @@ local.get $3 return ) - (func $start:assembly/instructions/rot~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) + (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) + (local $newBucketsCapacity i32) + (local $newBuckets i32) + (local $newEntriesCapacity i32) + (local $newEntries i32) + (local $oldPtr i32) + (local $oldEnd i32) + (local $newPtr i32) + (local $oldEntry i32) + (local $newEntry i32) + (local $oldEntryKey i32) + (local $newBucketIndex i32) + (local $newBucketPtrBase i32) + (local $14 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -21726,132 +21747,196 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 + i64.const 0 + i64.store offset=8 + local.get $newBucketsMask + i32.const 1 + i32.add + local.set $newBucketsCapacity global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 0 + local.get $newBucketsCapacity + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newBuckets i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - local.get $regs - local.set $3 + local.get $newBucketsCapacity + i32.const 8 + i32.mul + i32.const 3 + i32.div_s + local.set $newEntriesCapacity global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 0 + local.get $newEntriesCapacity + block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.0" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newEntries i32.store offset=4 - local.get $3 - local.get $args - local.set $3 + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $14 i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 + local.get $14 + call $"~lib/map/Map#get:entries" + local.set $oldPtr + local.get $oldPtr + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 12 + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.1" + end + i32.mul i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) + local.set $oldEnd + local.get $newEntries + local.set $newPtr + loop $while-continue|0 + local.get $oldPtr + local.get $oldEnd + i32.ne + if + local.get $oldPtr + local.set $oldEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $newPtr + local.set $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:key" + local.set $oldEntryKey + local.get $newEntry + local.get $oldEntryKey + call $"~lib/map/MapEntry#set:key" + local.get $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:value" + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/MapEntry#set:value" + local.get $oldEntryKey + call $~lib/util/hash/HASH + local.get $newBucketsMask + i32.and + local.set $newBucketIndex + local.get $newBuckets + local.get $newBucketIndex + i32.const 4 + i32.mul + i32.add + local.set $newBucketPtrBase + local.get $newEntry + local.get $newBucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $newBucketPtrBase + local.get $newPtr + i32.store + local.get $newPtr + block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.2" + end + i32.add + local.set $newPtr + end + local.get $oldPtr + block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.3" + end + i32.add + local.set $oldPtr + br $while-continue|0 + end + end + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBuckets + local.set $14 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 0 + local.get $14 i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 + local.get $14 + local.get $newBucketsMask + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntries + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $14 i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 + local.get $14 + local.get $newEntriesCapacity + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $14 i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_l - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 + local.get $14 + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 12 + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#get:entriesCount" + call $"~lib/map/Map#set:entriesOffset" + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 - return ) - (func $start:assembly/instructions/rot~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) + (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) + (local $hashCode i32) + (local $entry i32) + (local $entries i32) + (local $6 i32) + (local $bucketPtrBase i32) + (local $8 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub @@ -21863,142 +21948,421 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $regs - local.set $3 + local.get $key + call $~lib/util/hash/HASH + local.set $hashCode + local.get $this + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $8 i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_l_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 + local.get $8 + local.get $key + local.get $hashCode + call $"~lib/map/Map#find" + local.set $entry + local.get $entry + if + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.eq + if + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.const 3 + i32.mul + i32.const 4 + i32.div_s + i32.lt_s + if (result i32) + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.const 1 + i32.shl + i32.const 1 + i32.or + end + call $"~lib/map/Map#rehash" + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.tee $entries + i32.store offset=8 + local.get $entries + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.tee $6 + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesOffset" + local.get $6 + block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.4" + end + i32.mul + i32.add + local.set $entry + local.get $entry + local.get $key + call $"~lib/map/MapEntry#set:key" + i32.const 0 + drop + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + local.set $bucketPtrBase + local.get $entry + local.get $bucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $bucketPtrBase + local.get $entry + i32.store + end + local.get $this + local.set $8 global.get $~lib/memory/__stack_pointer i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $8 return ) - (func $start:assembly/instructions/rot~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) + (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) + (local $freeMemoryStart i32) + (local $newSbrk i64) + (local $pageIdx i32) + (local $i i32) + (local $page i32) + (local $7 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 + i32.const 20 + memory.fill global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $freeMemoryStart i32.store - local.get $3 - local.get $args - local.set $3 + local.get $freeMemoryStart + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $7 i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c + local.get $7 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 + call $assembly/memory/Result#set:ok + local.get $amount + i32.const 0 + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $7 i32.store offset=4 - local.get $3 - local.get $args - local.set $3 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + local.get $amount + i64.extend_i32_u + i64.add + local.set $newSbrk + local.get $newSbrk + global.get $assembly/memory/MEMORY_SIZE + i64.ge_s + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Result#get:fault + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isFault + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b + local.get $7 + i32.store offset=4 + local.get $7 + local.get $newSbrk + i32.wrap_i64 + call $assembly/memory/Memory#set:sbrkAddress + local.get $newSbrk + i64.const 1 + i64.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $regs - local.set $3 + i64.shr_s + i32.wrap_i64 + local.set $pageIdx + local.get $pageIdx + local.get $this + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $7 i32.store offset=4 - local.get $3 - local.get $args - local.set $3 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.const 1 + i32.add + local.set $i + loop $for-loop|0 + local.get $i + local.get $pageIdx + i32.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:arena + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=12 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory/Memory#get:pages + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $i + i32.const 0 + global.get $assembly/memory-page/Access.Write + local.get $page + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory-page/Page#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $"~lib/map/Map#set" + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $7 global.get $~lib/memory/__stack_pointer - i32.const 12 + local.get $7 + i32.store offset=4 + local.get $7 + local.get $pageIdx + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $7 return ) - (func $start:assembly/instructions/rot~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) + (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $res i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -22006,106 +22370,70 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 + i64.const 0 + i64.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 + local.get $memory + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 + local.get $4 + i32.store + local.get $4 + local.get $registers + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $4 i32.store offset=4 - local.get $3 + local.get $4 local.get $args - local.set $3 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $4 i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 + local.get $4 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get i32.wrap_i64 - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/set~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args + call $assembly/memory/Memory#sbrk + local.tee $res + i32.store offset=12 + local.get $res local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args + call $assembly/memory/Result#get:fault local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.lt_u - local.set $cond + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer @@ -22121,93 +22449,79 @@ call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer local.get $4 return ) - (func $start:assembly/instructions/set~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) + (func $start:assembly/instructions/mov~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 local.get $registers - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store - local.get $4 + local.get $3 local.get $args - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a + local.get $3 + call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.lt_s - local.set $cond local.get $registers - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 + local.get $3 + i32.store offset=4 + local.get $3 local.get $args - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end + call $~lib/staticarray/StaticArray#__get call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $3 return ) - (func $start:assembly/instructions/set~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) + (func $start:assembly/instructions/mov~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -22217,65 +22531,60 @@ i64.const 0 i64.store local.get $registers - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store - local.get $4 + local.get $3 local.get $args - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store offset=4 - local.get $4 + local.get $3 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.gt_u - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set end - call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $3 return ) - (func $start:assembly/instructions/set~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) + (func $start:assembly/instructions/mov~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -22285,63 +22594,133 @@ i64.const 0 i64.store local.get $registers - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store - local.get $4 + local.get $3 local.get $args - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store offset=4 - local.get $4 + local.get $3 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 + i64.const 0 + i64.ne + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.gt_s - local.set $cond + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/mov~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 local.get $registers - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store - local.get $4 + local.get $3 local.get $args - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b + local.get $3 + call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.eq + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set end - call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $3 return ) - (func $start:assembly/instructions/set~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/mov~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 12 @@ -22366,26 +22745,84 @@ local.get $3 i32.store offset=4 local.get $3 - call $assembly/arguments/Args#get:c + call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $registers + call $~lib/staticarray/StaticArray#__get + i64.const 0 + i64.ne + if + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/ok local.set $3 global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 + return + ) + (func $start:assembly/instructions/rot~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store local.get $3 local.get $args local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=8 + i32.store offset=4 local.get $3 call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers + local.get $regs local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -22401,12 +22838,15 @@ i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - i64.lt_u - if (result i64) - i64.const 1 - else - i64.const 0 - end + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/instructions/rot/math.rot_r call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok local.set $3 @@ -22417,7 +22857,7 @@ local.get $3 return ) - (func $start:assembly/instructions/set~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/rot~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 12 @@ -22430,7 +22870,7 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $registers + local.get $regs local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -22442,26 +22882,18 @@ local.get $3 i32.store offset=4 local.get $3 - call $assembly/arguments/Args#get:c + call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 local.get $args local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=8 + i32.store offset=4 local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $regs local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -22477,12 +22909,7 @@ i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - i64.lt_s - if (result i64) - i64.const 1 - else - i64.const 0 - end + call $assembly/instructions/rot/math.rot_r call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok local.set $3 @@ -22493,216 +22920,426 @@ local.get $3 return ) - (func $start:assembly/instructions/shift~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) + (func $start:assembly/instructions/rot~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $args - local.set $5 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $3 i32.store - local.get $5 + local.get $3 local.get $args - local.set $5 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $3 i32.store offset=4 - local.get $5 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 + local.get $args + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store - local.get $5 + local.get $3 local.get $args - local.set $5 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $3 i32.store offset=4 - local.get $5 + local.get $3 call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shl + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_r_32 call $assembly/instructions/utils/u32SignExtend call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $5 + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 + local.get $3 return ) - (func $start:assembly/instructions/shift~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) + (func $start:assembly/instructions/rot~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $args - local.set $5 global.get $~lib/memory/__stack_pointer - local.get $5 + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store - local.get $5 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 + local.get $3 + i32.store offset=4 + local.get $3 local.get $args - local.set $5 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store offset=4 - local.get $5 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 + call $assembly/instructions/rot/math.rot_l + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store - local.get $5 + local.get $3 local.get $args - local.set $5 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $3 i32.store offset=4 - local.get $5 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shr_u + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_l_32 call $assembly/instructions/utils/u32SignExtend call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $5 + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 + local.get $3 return ) - (func $start:assembly/instructions/shift~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) + (func $start:assembly/instructions/rot~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $args - local.set $5 global.get $~lib/memory/__stack_pointer - local.get $5 + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store - local.get $5 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 + local.get $3 + i32.store offset=4 + local.get $3 local.get $args - local.set $5 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store offset=4 - local.get $5 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $value - local.get $registers - local.set $5 + call $assembly/instructions/rot/math.rot_r + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/rot~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store - local.get $5 + local.get $3 local.get $args - local.set $5 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $3 i32.store offset=4 - local.get $5 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $value - local.get $shift + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.get $regs + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a i64.extend_i32_u - i64.shr_s + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/instructions/rot/math.rot_r_32 + call $assembly/instructions/utils/u32SignExtend call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $5 + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 + local.get $3 return ) - (func $start:assembly/instructions/shift~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) + (func $start:assembly/instructions/set~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 8 @@ -22728,36 +23365,37 @@ i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers + local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - local.get $args + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.lt_u + local.set $cond + local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=4 + i32.store local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:c - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok local.set $4 @@ -22768,8 +23406,8 @@ local.get $4 return ) - (func $start:assembly/instructions/shift~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) + (func $start:assembly/instructions/set~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 8 @@ -22795,36 +23433,37 @@ i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers + local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - local.get $args + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.lt_s + local.set $cond + local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=4 + i32.store local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:c - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok local.set $4 @@ -22835,10 +23474,9 @@ local.get $4 return ) - (func $start:assembly/instructions/shift~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $imm i64) - (local $5 i32) + (func $start:assembly/instructions/set~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -22848,80 +23486,89 @@ i64.const 0 i64.store local.get $registers - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 + local.get $4 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 + local.get $4 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 + local.get $4 call $assembly/arguments/Args#get:c call $assembly/instructions/utils/u32SignExtend - local.set $imm + i64.gt_u + local.set $cond local.get $registers - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 + local.get $4 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 + local.get $4 call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $imm - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 + local.get $4 return ) - (func $start:assembly/instructions/shift~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) + (func $start:assembly/instructions/set~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $cond i32) (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + local.get $registers + local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get local.get $args local.set $4 global.get $~lib/memory/__stack_pointer @@ -22929,9 +23576,9 @@ i32.store local.get $4 call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift + call $assembly/instructions/utils/u32SignExtend + i64.gt_s + local.set $cond local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer @@ -22947,38 +23594,100 @@ call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $registers + local.get $cond + if (result i64) + i64.const 1 + else + i64.const 0 + end + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok local.set $4 global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer local.get $4 + return + ) + (func $start:assembly/instructions/set~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store offset=4 - local.get $4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 local.get $args - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a + local.get $3 + call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - local.get $shift + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/arguments/Args#get:a i64.extend_i32_u - i64.shl + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.lt_u + if (result i64) + i64.const 1 + else + i64.const 0 + end call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $3 return ) - (func $start:assembly/instructions/shift~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) + (func $start:assembly/instructions/set~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub @@ -22990,63 +23699,72 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $args - local.set $4 + local.get $registers + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store - local.get $4 + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift + i64.extend_i32_u + call $assembly/instructions/utils/reg local.get $registers - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 + local.get $3 + i32.store offset=4 + local.get $3 local.get $args - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 + local.get $3 + i32.store offset=8 + local.get $3 call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get local.get $registers - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store offset=4 - local.get $4 + local.get $3 local.get $args - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store offset=8 - local.get $4 + local.get $3 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_u + i64.lt_s + if (result i64) + i64.const 1 + else + i64.const 0 + end call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $3 return ) - (func $start:assembly/instructions/shift~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) (local $shift i32) - (local $value i64) + (local $value i32) (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 8 @@ -23063,7 +23781,7 @@ i32.store local.get $5 call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 + global.get $assembly/instructions/shift/MAX_SHIFT_32 i32.rem_u local.set $shift local.get $registers @@ -23082,6 +23800,7 @@ i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 local.set $value local.get $registers local.set $5 @@ -23100,8 +23819,8 @@ call $assembly/instructions/utils/reg local.get $value local.get $shift - i64.extend_i32_u - i64.shr_s + i32.shl + call $assembly/instructions/utils/u32SignExtend call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok local.set $5 @@ -23112,9 +23831,10 @@ local.get $5 return ) - (func $start:assembly/instructions/shift~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) (local $shift i32) - (local $4 i32) + (local $value i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -23123,132 +23843,64 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 + local.get $5 call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift local.get $registers - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store - local.get $4 + local.get $5 local.get $args - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store offset=4 - local.get $4 + local.get $5 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u i32.wrap_i64 - local.set $shift + local.set $value local.get $registers - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store - local.get $4 + local.get $5 local.get $args - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store offset=4 - local.get $4 + local.get $5 call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend + local.get $value local.get $shift - i64.extend_i32_u - i64.shr_u + i32.shr_u + call $assembly/instructions/utils/u32SignExtend call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $5 return ) - (func $start:assembly/instructions/shift~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) (local $shift i32) (local $value i64) (local $5 i32) @@ -23260,6 +23912,16 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i32.rem_u + local.set $shift local.get $registers local.set $5 global.get $~lib/memory/__stack_pointer @@ -23276,18 +23938,7 @@ i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u i32.wrap_i64 - local.set $shift - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c call $assembly/instructions/utils/u32SignExtend local.set $value local.get $registers @@ -23309,8 +23960,6 @@ local.get $shift i64.extend_i32_u i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok local.set $5 @@ -23321,10 +23970,9 @@ local.get $5 return ) - (func $start:assembly/instructions/shift~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) (local $shift i32) - (local $value i32) - (local $5 i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -23334,17 +23982,17 @@ i64.const 0 i64.store local.get $registers - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 + local.get $4 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 + local.get $4 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg @@ -23355,56 +24003,43 @@ i32.wrap_i64 local.set $shift local.get $registers - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 + local.get $4 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 + local.get $4 call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 + local.get $4 call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value local.get $shift i32.shl call $assembly/instructions/utils/u32SignExtend call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 + local.get $4 return ) - (func $start:assembly/instructions/shift~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) (local $shift i32) - (local $value i32) - (local $5 i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -23414,17 +24049,17 @@ i64.const 0 i64.store local.get $registers - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 + local.get $4 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 + local.get $4 call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg @@ -23435,55 +24070,43 @@ i32.wrap_i64 local.set $shift local.get $registers - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 + local.get $4 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 + local.get $4 call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 + local.get $4 call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value local.get $shift i32.shr_u call $assembly/instructions/utils/u32SignExtend call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 + local.get $4 return ) - (func $start:assembly/instructions/shift~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) (local $shift i32) - (local $regValue i64) + (local $imm i64) (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 8 @@ -23514,25 +24137,15 @@ i64.rem_u i32.wrap_i64 local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store offset=4 + i32.store local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 + call $assembly/arguments/Args#get:c call $assembly/instructions/utils/u32SignExtend - local.set $regValue + local.set $imm local.get $registers local.set $5 global.get $~lib/memory/__stack_pointer @@ -23545,10 +24158,10 @@ local.get $5 i32.store offset=4 local.get $5 - call $assembly/arguments/Args#get:c + call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $regValue + local.get $imm local.get $shift i64.extend_i32_u i64.shr_s @@ -23564,7 +24177,7 @@ local.get $5 return ) - (func $start:assembly/instructions/shift~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) (local $shift i32) (local $4 i32) global.get $~lib/memory/__stack_pointer @@ -23578,26 +24191,15 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=4 + i32.store local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get + call $assembly/arguments/Args#get:c global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 + i32.rem_u local.set $shift local.get $registers local.set $4 @@ -23611,7 +24213,7 @@ local.get $4 i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:c + call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg local.get $registers @@ -23626,7 +24228,7 @@ local.get $4 i32.store offset=8 local.get $4 - call $assembly/arguments/Args#get:b + call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get @@ -23643,7 +24245,7 @@ local.get $4 return ) - (func $start:assembly/instructions/shift~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) (local $shift i32) (local $4 i32) global.get $~lib/memory/__stack_pointer @@ -23657,26 +24259,15 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=4 + i32.store local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get + call $assembly/arguments/Args#get:c global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 + i32.rem_u local.set $shift local.get $registers local.set $4 @@ -23690,7 +24281,7 @@ local.get $4 i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:c + call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg local.get $registers @@ -23705,7 +24296,7 @@ local.get $4 i32.store offset=8 local.get $4 - call $assembly/arguments/Args#get:b + call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get @@ -23722,20 +24313,85 @@ local.get $4 return ) - (func $start:assembly/instructions/shift~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) (local $shift i32) - (local $4 i32) + (local $value i64) + (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i32.rem_u + local.set $shift + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.set $value + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/shift~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer @@ -23769,406 +24425,210 @@ local.get $4 i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:c + call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=8 + i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend local.get $shift i64.extend_i32_u - i64.shr_s + i64.shl call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/ok local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer local.get $4 return ) - (func $~lib/typedarray/Uint8Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - i32.ge_u - if - i32.const 480 - i32.const 720 - i32.const 178 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $index - i32.add - local.get $value - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU8 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) + (func $start:assembly/instructions/shift~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this + local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 1 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res + local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=8 + i32.store offset=4 local.get $4 - call $assembly/memory/Chunks#get:fault + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first + local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store + i32.store offset=4 local.get $4 - i32.const 0 - local.get $value - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $res + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store + i32.store offset=4 local.get $4 - call $assembly/memory/Chunks#get:fault + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer local.get $4 return ) - (func $start:assembly/instructions/store~anonymous|0 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) + (func $start:assembly/instructions/shift~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i64) (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args + local.get $registers local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory + local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store + i32.store offset=4 local.get $5 - local.get $address + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store offset=4 + i32.store local.get $5 - call $assembly/arguments/Args#get:b - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + local.set $value + local.get $registers local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - call $assembly/instructions/outcome/okOrFault + local.get $args local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer local.get $5 - return - ) - (func $assembly/memory/Memory#setU16 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 2 - call $assembly/memory/Memory#getChunks - local.tee $res i32.store offset=4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg local.get $value - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.gt_s - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $value - i32.const 65535 - i32.and - i32.const 8 - i32.const 15 - i32.and - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - else - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 65535 - i32.and - i32.const 8 - i32.const 15 - i32.and - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $5 return ) - (func $start:assembly/instructions/store~anonymous|1 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) + (func $start:assembly/instructions/shift~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + local.get $registers + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 + local.get $5 + i32.store + local.get $5 local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store + i32.store offset=4 local.get $5 call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - local.get $address local.get $args local.set $5 global.get $~lib/memory/__stack_pointer @@ -24176,230 +24636,79 @@ i32.store offset=4 local.get $5 call $assembly/arguments/Args#get:b - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - call $assembly/instructions/outcome/okOrFault + local.get $args local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 12 + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $value + local.get $shift + i32.shl + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer local.get $5 return ) - (func $assembly/memory/Memory#setU32 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $v i32) - (local $len i32) - (local $i i32) - (local $i|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 4 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $value - local.set $v - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - local.get $v - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i32.const 8 - i32.shr_u - local.set $v - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i|7 - local.get $v - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i32.const 8 - i32.shr_u - local.set $v - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/instructions/store~anonymous|2 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) + (func $start:assembly/instructions/shift~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $value i32) (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + local.get $registers + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 + local.get $5 + i32.store + local.get $5 local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store + i32.store offset=4 local.get $5 call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - local.get $address local.get $args local.set $5 global.get $~lib/memory/__stack_pointer @@ -24407,230 +24716,79 @@ i32.store offset=4 local.get $5 call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#setU32 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $value + local.get $registers local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - call $assembly/instructions/outcome/okOrFault + local.get $args local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer local.get $5 - return - ) - (func $assembly/memory/Memory#setU64 (param $this i32) (param $address i32) (param $value i64) (result i32) - (local $res i32) - (local $v i64) - (local $len i32) - (local $i i32) - (local $i|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 8 - call $assembly/memory/Memory#getChunks - local.tee $res i32.store offset=4 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg local.get $value - local.set $v - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - local.get $v - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i64.const 8 - i64.shr_u - local.set $v - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i|7 - local.get $v - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i64.const 8 - i64.shr_u - local.set $v - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 + local.get $shift + i32.shr_u + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $8 + local.get $5 return ) - (func $start:assembly/instructions/store~anonymous|3 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) + (func $start:assembly/instructions/shift~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $regValue i64) (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + local.get $registers + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 + local.get $5 + i32.store + local.get $5 local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store + i32.store offset=4 local.get $5 call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_32 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - local.get $address local.get $args local.set $5 global.get $~lib/memory/__stack_pointer @@ -24638,30 +24796,48 @@ i32.store offset=4 local.get $5 call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Memory#setU64 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault + local.set $regValue + local.get $registers local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - call $assembly/instructions/outcome/okOrFault + local.get $args local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 12 + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $regValue + local.get $shift + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer local.get $5 return ) - (func $start:assembly/instructions/store~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) + (func $start:assembly/instructions/shift~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -24669,10 +24845,9 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory + i32.const 0 + i32.store offset=8 + local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 @@ -24684,60 +24859,74 @@ local.get $4 i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:b + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=4 + i32.store local.get $4 local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=8 + i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:a + call $assembly/arguments/Args#get:c i64.extend_i32_u call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $fault - i32.store offset=12 - local.get $fault + local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store + i32.store offset=4 local.get $4 - call $assembly/instructions/outcome/okOrFault + local.get $args local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/shift~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 - i64.store offset=8 + i64.store global.get $~lib/memory/__stack_pointer - local.get $memory + i32.const 0 + i32.store offset=8 + local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 @@ -24749,49 +24938,64 @@ local.get $4 i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:b + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=4 + i32.store local.get $4 local.get $args local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=8 + i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:a + call $assembly/arguments/Args#get:c i64.extend_i32_u call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $fault - i32.store offset=12 - local.get $fault + local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store + i32.store offset=4 local.get $4 - call $assembly/instructions/outcome/okOrFault + local.get $args local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 16 + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $shift + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer local.get $4 return ) - (func $start:assembly/instructions/store~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) + (func $start:assembly/instructions/shift~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $shift i32) (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -24799,10 +25003,30 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $memory + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + global.get $assembly/instructions/shift/MAX_SHIFT_64 + i64.extend_i32_s + i64.rem_u + i32.wrap_i64 + local.set $shift + local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 @@ -24814,7 +25038,9 @@ local.get $4 i32.store offset=4 local.get $4 - call $assembly/arguments/Args#get:b + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg local.get $registers local.set $4 global.get $~lib/memory/__stack_pointer @@ -24827,34 +25053,71 @@ local.get $4 i32.store offset=8 local.get $4 - call $assembly/arguments/Args#get:a + call $assembly/arguments/Args#get:b i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $fault - i32.store offset=12 - local.get $fault + local.get $shift + i64.extend_i32_u + i64.shr_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok local.set $4 global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer local.get $4 + return + ) + (func $~lib/typedarray/Uint8Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 + local.get $index + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 16 + local.get $3 + i32.store + local.get $3 + call $~lib/arraybuffer/ArrayBufferView#get:byteLength + i32.ge_u + if + i32.const 480 + i32.const 720 + i32.const 178 + i32.const 45 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $index + i32.add + local.get $value + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 - return ) - (func $start:assembly/instructions/store~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) + (func $assembly/memory/Memory#setU8 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -24862,57 +25125,83 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $memory + local.get $this local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - local.get $args + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 1 + call $assembly/memory/Memory#getChunks + local.tee $res + i32.store offset=4 + local.get $res local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=4 + i32.store offset=8 local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers + call $assembly/memory/Chunks#get:fault local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=4 + i32.store local.get $4 - local.get $args + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $res local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store offset=8 local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $fault - i32.store offset=12 - local.get $fault + call $assembly/memory/Chunks#get:first local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - call $assembly/instructions/outcome/okOrFault + i32.const 0 + local.get $value + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $res local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 16 + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer local.get $4 return ) - (func $start:assembly/instructions/store~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (func $start:assembly/instructions/store~anonymous|0 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) (local $address i32) (local $pageFault i32) (local $5 i32) @@ -24927,32 +25216,13 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 + call $assembly/arguments/Args#get:a local.set $address global.get $~lib/memory/__stack_pointer local.get $memory @@ -24968,7 +25238,7 @@ local.get $5 i32.store offset=4 local.get $5 - call $assembly/arguments/Args#get:c + call $assembly/arguments/Args#get:b i32.const 255 i32.and call $assembly/memory/Memory#setU8 @@ -24989,10 +25259,9 @@ local.get $5 return ) - (func $start:assembly/instructions/store~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) + (func $assembly/memory/Memory#setU16 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub @@ -25004,69 +25273,141 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $registers - local.set $5 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 + local.get $this + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 + i32.store + local.get $4 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 2 + call $assembly/memory/Memory#getChunks + local.tee $res i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 + local.get $res + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $res + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 65535 + local.get $4 + i32.const 0 + local.get $value + i32.const 255 i32.and - call $assembly/memory/Memory#setU16 - local.tee $pageFault + call $~lib/typedarray/Uint8Array#__set + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 i32.store offset=8 - local.get $pageFault - local.set $5 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.gt_s + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:first + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 1 + local.get $value + i32.const 65535 + i32.and + i32.const 8 + i32.const 15 + i32.and + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + else + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/memory/Chunks#get:second + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + local.get $value + i32.const 65535 + i32.and + i32.const 8 + i32.const 15 + i32.and + i32.shr_u + call $~lib/typedarray/Uint8Array#__set + end + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/Chunks#get:fault + local.set $4 global.get $~lib/memory/__stack_pointer i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 + local.get $4 return ) - (func $start:assembly/instructions/store~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (func $start:assembly/instructions/store~anonymous|1 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) (local $address i32) (local $pageFault i32) (local $5 i32) @@ -25081,32 +25422,13 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 + call $assembly/arguments/Args#get:a local.set $address global.get $~lib/memory/__stack_pointer local.get $memory @@ -25122,8 +25444,10 @@ local.get $5 i32.store offset=4 local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/memory/Memory#setU32 + call $assembly/arguments/Args#get:b + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 local.tee $pageFault i32.store offset=8 local.get $pageFault @@ -25141,10 +25465,13 @@ local.get $5 return ) - (func $start:assembly/instructions/store~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) + (func $assembly/memory/Memory#setU32 (param $this i32) (param $address i32) (param $value i32) (result i32) + (local $res i32) + (local $v i32) + (local $len i32) + (local $i i32) + (local $i|7 i32) + (local $8 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub @@ -25156,73 +25483,167 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $registers - local.set $5 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 + local.get $this + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 4 + call $assembly/memory/Memory#getChunks + local.tee $res i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 + local.get $res + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $8 i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $value + local.set $v + local.get $res + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Memory#setU64 - local.tee $pageFault + local.get $8 i32.store offset=8 - local.get $pageFault - local.set $5 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $8 i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + local.get $v + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i32.const 8 + i32.shr_u + local.set $v + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i|7 + local.get $v + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i32.const 8 + i32.shr_u + local.set $v + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 global.get $~lib/memory/__stack_pointer i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 + local.get $8 return ) - (func $start:assembly/instructions/store~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (func $start:assembly/instructions/store~anonymous|2 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) (local $address i32) - (local $fault i32) + (local $pageFault i32) (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -25230,34 +25651,15 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get + i32.const 0 + i32.store offset=8 local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 + call $assembly/arguments/Args#get:a local.set $address global.get $~lib/memory/__stack_pointer local.get $memory @@ -25267,29 +25669,17 @@ i32.store local.get $5 local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store offset=8 + i32.store offset=4 local.get $5 call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $fault - i32.store offset=12 - local.get $fault + call $assembly/memory/Memory#setU32 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 @@ -25298,18 +25688,21 @@ call $assembly/instructions/outcome/okOrFault local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer local.get $5 return ) - (func $start:assembly/instructions/store~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) + (func $assembly/memory/Memory#setU64 (param $this i32) (param $address i32) (param $value i64) (result i32) + (local $res i32) + (local $v i64) + (local $len i32) + (local $i i32) + (local $i|7 i32) + (local $8 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -25317,34 +25710,187 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 + local.get $this + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $8 + i32.store + local.get $8 + global.get $assembly/memory-page/Access.Write + local.get $address + i32.const 8 + call $assembly/memory/Memory#getChunks + local.tee $res i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + end + local.get $value + local.set $v + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:first + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + local.get $v + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i64.const 8 + i64.shr_u + local.set $v + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/memory/Chunks#get:second + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i|7 + local.get $v + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $v + i64.const 8 + i64.shr_u + local.set $v + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $assembly/memory/Chunks#get:fault + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $start:assembly/instructions/store~anonymous|3 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 + call $assembly/arguments/Args#get:a local.set $address global.get $~lib/memory/__stack_pointer local.get $memory @@ -25354,29 +25900,18 @@ i32.store local.get $5 local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store offset=8 + i32.store offset=4 local.get $5 call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $fault - i32.store offset=12 - local.get $fault + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Memory#setU64 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 @@ -25385,16 +25920,15 @@ call $assembly/instructions/outcome/okOrFault local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer local.get $5 return ) - (func $start:assembly/instructions/store~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) + (func $start:assembly/instructions/store~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) (local $fault i32) - (local $5 i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub @@ -25406,80 +25940,60 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store offset=8 - local.get $registers - local.set $5 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 i32.store - local.get $5 + local.get $4 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address + local.get $4 + call $assembly/arguments/Args#get:b local.get $registers - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 + local.get $4 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b + local.get $4 + call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and i32.wrap_i64 - call $assembly/memory/Memory#setU32 + call $assembly/memory/Memory#setU8 local.tee $fault i32.store offset=12 local.get $fault - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 + local.get $4 call $assembly/instructions/outcome/okOrFault - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 + local.get $4 return ) - (func $start:assembly/instructions/store~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) + (func $start:assembly/instructions/store~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) (local $fault i32) - (local $5 i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub @@ -25491,80 +26005,62 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store offset=8 - local.get $registers - local.set $5 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 i32.store - local.get $5 + local.get $4 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address + local.get $4 + call $assembly/arguments/Args#get:b local.get $registers - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 + local.get $4 local.get $args - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b + local.get $4 + call $assembly/arguments/Args#get:a i64.extend_i32_u call $assembly/instructions/utils/reg call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 local.tee $fault i32.store offset=12 local.get $fault - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store - local.get $5 + local.get $4 call $assembly/instructions/outcome/okOrFault - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 + local.get $4 return ) - (func $assembly/instructions/outcome/status (param $result i32) (result i32) - (local $r i32) - (local $2 i32) + (func $start:assembly/instructions/store~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -25572,40 +26068,62 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 i32.store - local.get $r - local.set $2 + local.get $4 + local.get $args + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $4 i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $4 i32.store offset=4 - local.get $2 - local.get $result - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 + local.get $4 + local.get $args + local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $4 return ) - (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) - (local $r i32) - (local $2 i32) + (func $start:assembly/instructions/store~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $fault i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -25613,185 +26131,289 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 i32.store - local.get $r - local.set $2 + local.get $4 + local.get $args + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $4 i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 + local.get $4 + call $assembly/arguments/Args#get:b + local.get $registers + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $4 i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Result.HOST - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 + local.get $4 + local.get $args + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $id - call $assembly/instructions/outcome/OutcomeData#set:exitCode - local.get $r - local.set $2 + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $4 return ) - (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) + (func $start:assembly/instructions/store~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 i32.store + local.get $5 local.get $args - local.set $3 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 + local.get $5 + i32.store offset=4 + local.get $5 call $assembly/arguments/Args#get:a - call $assembly/instructions/outcome/hostCall - local.set $3 + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check + local.get $memory + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 0 + local.get $5 i32.store - local.get $this - local.set $1 + local.get $5 + local.get $address + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 255 + i32.and + call $assembly/memory/Memory#setU8 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $1 + local.get $5 return ) - (func $~lib/array/Array#pop (param $this i32) (result i32) - (local $len i32) - (local $val i32) - (local $3 i32) + (func $start:assembly/instructions/store~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $this - local.set $3 global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 i32.store - local.get $3 - call $~lib/array/Array#get:length_ - local.set $len - local.get $len - i32.const 1 - i32.lt_s - if - i32.const 13120 - i32.const 8128 - i32.const 271 - i32.const 18 - call $~lib/builtins/abort - unreachable - end + local.get $5 + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $5 i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $len - i32.const 1 - i32.sub - local.tee $len - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $val + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 i32.store offset=4 - local.get $this - local.set $3 + local.get $5 + call $assembly/arguments/Args#get:c + i32.const 65535 + i32.and + call $assembly/memory/Memory#setU16 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $5 i32.store - local.get $3 - local.get $len - call $~lib/array/Array#set:length_ - local.get $val - local.set $3 + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $5 return ) - (func $~lib/console/console.log (param $message i32) - (local $1 i32) + (func $start:assembly/instructions/store~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer i32.const 0 + i32.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 i32.store - local.get $message - local.set $1 + local.get $5 + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 i32.store - local.get $1 - call $~lib/bindings/dom/console.log + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/memory/Memory#setU32 + local.tee $pageFault + i32.store offset=8 + local.get $pageFault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer + local.get $5 + return ) - (func $assembly/memory-page/Arena#acquire (param $this i32) (result i32) - (local $allocatedMemory i32) - (local $data i32) - (local $3 i32) + (func $start:assembly/instructions/store~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $pageFault i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub @@ -25803,137 +26425,158 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $this - local.set $3 + local.get $registers + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:free - local.set $3 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $5 i32.store - local.get $3 - call $~lib/array/Array#get:length - i32.const 0 - i32.gt_s - if - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:free - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#pop - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $this - local.set $3 + local.get $5 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.set $allocatedMemory - local.get $allocatedMemory - local.get $this - local.set $3 + local.get $memory + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $5 i32.store - local.get $3 - call $assembly/memory-page/Arena#get:arenaBytes - i32.eq - if - i32.const 13168 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/console/console.log - end + local.get $5 + local.get $address + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $allocatedMemory - global.get $assembly/memory-page/ALLOCATE_EAGERLY - i32.lt_u - if (result i32) - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - else - i32.const 0 - end - local.tee $data + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/memory/Memory#setU64 + local.tee $pageFault i32.store offset=8 - local.get $this - local.set $3 + local.get $pageFault + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $5 i32.store - local.get $3 - local.get $this - local.set $3 + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - i32.const 1 + i32.const 12 i32.add - call $assembly/memory-page/Arena#set:extraPageIndex - i32.const 0 - local.get $this - local.set $3 + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - local.get $data - local.set $3 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $5 i32.store - local.get $3 - call $assembly/memory-page/RawPage#constructor - local.set $3 + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address global.get $~lib/memory/__stack_pointer - i32.const 12 + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 255 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU8 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $5 return ) - (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) - (local $newBucketsCapacity i32) - (local $newBuckets i32) - (local $newEntriesCapacity i32) - (local $newEntries i32) - (local $oldPtr i32) - (local $oldEnd i32) - (local $newPtr i32) - (local $oldEntry i32) - (local $newEntry i32) - (local $oldEntryKey i32) - (local $newBucketIndex i32) - (local $newBucketPtrBase i32) - (local $14 i32) + (func $start:assembly/instructions/store~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub @@ -25945,196 +26588,169 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store offset=8 - local.get $newBucketsMask - i32.const 1 - i32.add - local.set $newBucketsCapacity + local.get $registers + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newBucketsCapacity - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newBuckets + local.get $5 i32.store - local.get $newBucketsCapacity - i32.const 8 - i32.mul - i32.const 3 - i32.div_s - local.set $newEntriesCapacity + local.get $5 + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newEntriesCapacity - block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.0" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newEntries + local.get $5 i32.store offset=4 - local.get $this - local.set $14 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entries" - local.set $oldPtr - local.get $oldPtr - local.get $this - local.set $14 + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.1" - end - i32.mul + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i64.const 65535 + i64.and + i32.wrap_i64 + call $assembly/memory/Memory#setU16 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.add - local.set $oldEnd - local.get $newEntries - local.set $newPtr - loop $while-continue|0 - local.get $oldPtr - local.get $oldEnd - i32.ne - if - local.get $oldPtr - local.set $oldEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $newPtr - local.set $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:key" - local.set $oldEntryKey - local.get $newEntry - local.get $oldEntryKey - call $"~lib/map/MapEntry#set:key" - local.get $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:value" - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/MapEntry#set:value" - local.get $oldEntryKey - call $~lib/util/hash/HASH - local.get $newBucketsMask - i32.and - local.set $newBucketIndex - local.get $newBuckets - local.get $newBucketIndex - i32.const 4 - i32.mul - i32.add - local.set $newBucketPtrBase - local.get $newEntry - local.get $newBucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $newBucketPtrBase - local.get $newPtr - i32.store - local.get $newPtr - block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.2" - end - i32.add - local.set $newPtr - end - local.get $oldPtr - block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.3" - end - i32.add - local.set $oldPtr - br $while-continue|0 - end - end - local.get $this - local.set $14 + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $start:assembly/instructions/store~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBuckets - local.set $14 + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $14 + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBucketsMask - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $14 + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntries - local.set $14 + local.get $5 + i32.store + local.get $5 + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $14 + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntriesCapacity - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $14 + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $this - local.set $14 + local.get $memory + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#setU32 + local.tee $fault i32.store offset=12 - local.get $14 - call $"~lib/map/Map#get:entriesCount" - call $"~lib/map/Map#set:entriesOffset" + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 global.get $~lib/memory/__stack_pointer i32.const 16 i32.add global.set $~lib/memory/__stack_pointer + local.get $5 + return ) - (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) - (local $hashCode i32) - (local $entry i32) - (local $entries i32) - (local $6 i32) - (local $bucketPtrBase i32) - (local $8 i32) + (func $start:assembly/instructions/store~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $address i32) + (local $fault i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -26142,527 +26758,331 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $key - call $~lib/util/hash/HASH - local.set $hashCode - local.get $this - local.set $8 + i64.const 0 + i64.store offset=8 + local.get $registers + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $8 + local.get $5 i32.store - local.get $8 - local.get $key - local.get $hashCode - call $"~lib/map/Map#find" - local.set $entry - local.get $entry - if - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.eq - if - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.const 3 - i32.mul - i32.const 4 - i32.div_s - i32.lt_s - if (result i32) - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.const 1 - i32.shl - i32.const 1 - i32.or - end - call $"~lib/map/Map#rehash" - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.tee $entries - i32.store offset=8 - local.get $entries - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.tee $6 - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesOffset" - local.get $6 - block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.4" - end - i32.mul - i32.add - local.set $entry - local.get $entry - local.get $key - call $"~lib/map/MapEntry#set:key" - i32.const 0 - drop - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - local.set $bucketPtrBase - local.get $entry - local.get $bucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $bucketPtrBase - local.get $entry - i32.store - end - local.get $this - local.set $8 + local.get $5 + local.get $args + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 12 + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + i64.add + i32.wrap_i64 + local.set $address + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $address + local.get $registers + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $args + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/memory/Memory#setU64 + local.tee $fault + i32.store offset=12 + local.get $fault + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/instructions/outcome/okOrFault + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $8 + local.get $5 return ) - (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) - (local $freeMemoryStart i32) - (local $newSbrk i64) - (local $pageIdx i32) - (local $i i32) - (local $page i32) - (local $7 i32) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $freeMemoryStart i32.store - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 local.get $this - local.set $7 + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $amount - i32.const 0 - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - local.get $amount - i64.extend_i32_u - i64.add - local.set $newSbrk - local.get $newSbrk - global.get $assembly/memory/MEMORY_SIZE - i64.ge_s - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Result#get:fault - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isFault - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $newSbrk - i32.wrap_i64 - call $assembly/memory/Memory#set:sbrkAddress - local.get $newSbrk - i64.const 1 - i64.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i64.extend_i32_s - i64.shr_s - i32.wrap_i64 - local.set $pageIdx - local.get $pageIdx + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index local.get $this - local.set $7 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.eq + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable end local.get $this - local.set $7 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.const 1 + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 0 + i32.shl i32.add - local.set $i - loop $for-loop|0 - local.get $i - local.get $pageIdx - i32.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:arena - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=12 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory/Memory#get:pages - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $i - i32.const 0 - global.get $assembly/memory-page/Access.Write - local.get $page - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory-page/Page#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $"~lib/map/Map#set" - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $pageIdx - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $freeMemoryStart - local.set $7 + i32.load8_u + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $7 + local.get $3 return ) - (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $res i32) - (local $4 i32) + (func $start:assembly/codec~anonymous|0 (param $firstByte i32) (result i32) + (local $len i32) + (local $i i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + i32.const 0 + i32.store + global.get $assembly/codec/MASKS + local.set $3 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.set $len + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.const 255 + i32.and + i32.lt_u + if + local.get $firstByte + i32.const 255 + i32.and + global.get $assembly/codec/MASKS + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $i + call $~lib/array/Array#__get + i32.ge_u + if + i32.const 8 + local.get $i + i32.sub + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - local.get $4 + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 i32.store - local.get $4 - local.get $registers - local.set $4 + local.get $index + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/program/Mask#isInstruction (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#sbrk - local.tee $res - i32.store offset=12 - local.get $res - local.set $4 + local.get $this + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $2 i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $2 i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i64.extend_i32_s + i64.ge_u if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 + i32.const 0 + local.set $2 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $2 return end - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 + local.get $this + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $2 i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $res - local.set $4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 + local.get $2 + i32.store + local.get $2 + local.get $index + call $~lib/staticarray/StaticArray#__get + i32.const 0 + i32.eq + local.set $2 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $2 return ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) + (func $~lib/array/Array#get:length (param $this i32) (result i32) (local $1 i32) global.get $~lib/memory/__stack_pointer i32.const 4 @@ -26678,7 +27098,7 @@ local.get $1 i32.store local.get $1 - call $~lib/array/Array#get:length_ + call $~lib/array/Array#get:length_ local.set $1 global.get $~lib/memory/__stack_pointer i32.const 4 @@ -26687,7 +27107,7 @@ local.get $1 return ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) (local $value i32) (local $3 i32) global.get $~lib/memory/__stack_pointer @@ -26705,7 +27125,7 @@ local.get $3 i32.store local.get $3 - call $~lib/array/Array#get:length_ + call $~lib/array/Array#get:length_ i32.ge_u if i32.const 480 @@ -26721,85 +27141,29 @@ local.get $3 i32.store local.get $3 - call $~lib/array/Array#get:dataStart + call $~lib/array/Array#get:dataStart local.get $index - i32.const 0 + i32.const 2 i32.shl i32.add - i32.load8_u + i32.load local.set $value + i32.const 1 + drop i32.const 0 + i32.eqz drop local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/codec~anonymous|0 (param $firstByte i32) (result i32) - (local $len i32) - (local $i i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $assembly/codec/MASKS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.const 255 - i32.and - i32.lt_u - if - local.get $firstByte - i32.const 255 - i32.and - global.get $assembly/codec/MASKS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $i - call $~lib/array/Array#__get - i32.ge_u - if - i32.const 8 - local.get $i - i32.sub - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end + i32.eqz + if + i32.const 14704 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable end - i32.const 0 + local.get $value local.set $3 global.get $~lib/memory/__stack_pointer i32.const 4 @@ -26808,158 +27172,127 @@ local.get $3 return ) - (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $9 i32) + (func $~lib/string/String#concat (param $this i32) (param $other i32) (result i32) + (local $thisSize i32) + (local $otherSize i32) + (local $outSize i32) + (local $out i32) + (local $6 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer local.get $this - local.tee $target - i32.store + local.set $6 global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $9 + local.get $6 + i32.store + local.get $6 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $thisSize + local.get $other + local.set $6 global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/array/Array#get:length - local.set $sourceLen - local.get $offset|5 + local.get $6 + i32.store + local.get $6 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $otherSize + local.get $thisSize + local.get $otherSize + i32.add + local.set $outSize + local.get $outSize i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end + i32.eq if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable + i32.const 14480 + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return end - local.get $target - local.set $9 global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl + local.get $outSize + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $out + local.get $this + local.get $thisSize + memory.copy + local.get $out + local.get $thisSize i32.add - local.set $targetStart - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/array/Array#get:dataStart - local.set $sourceStart - i32.const 0 - i32.eqz - drop - local.get $targetStart - local.get $sourceStart - local.get $sourceLen - i32.const 0 - i32.shl + local.get $other + local.get $otherSize memory.copy + local.get $out + local.set $6 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer + local.get $6 + return ) - (func $assembly/program/liftBytes (param $data i32) (result i32) - (local $p i32) + (func $~lib/string/String.__concat (param $left i32) (param $right i32) (result i32) (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $p - i32.store offset=4 - local.get $p + local.get $left local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 i32.store local.get $2 - local.get $data + local.get $right local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=8 + i32.store offset=4 local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#set<~lib/array/Array> - local.get $p + call $~lib/string/String#concat local.set $2 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer local.get $2 return ) - (func $assembly/codec/Decoder#constructor (param $this i32) (param $source i32) (param $offset i32) (result i32) - (local $3 i32) + (func $~lib/util/string/joinStringArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $4 i32) + (local $estLen i32) + (local $value i32) + (local $i i32) + (local $offset i32) + (local $sepLen i32) + (local $result i32) + (local $i|11 i32) + (local $valueLen i32) + (local $13 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -26967,100 +27300,38 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex i32.const 0 - i32.store offset=8 - local.get $this + i32.lt_s + if + i32.const 14480 + local.set $13 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $13 + return + end + local.get $lastIndex i32.eqz if global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 38 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $source - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/codec/Decoder#set:source - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $offset - call $assembly/codec/Decoder#set:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/util/string/joinStringArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $4 i32) - (local $estLen i32) - (local $value i32) - (local $i i32) - (local $offset i32) - (local $sepLen i32) - (local $result i32) - (local $i|11 i32) - (local $valueLen i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 14400 - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - end - local.get $lastIndex - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - i32.load - local.tee $4 + local.get $dataStart + i32.load + local.tee $4 i32.store local.get $4 if (result i32) local.get $4 else - i32.const 14400 + i32.const 14480 end local.set $13 global.get $~lib/memory/__stack_pointer @@ -27283,381 +27554,192 @@ local.get $2 return ) - (func $assembly/codec/Decoder#ensureBytes (param $this i32) (param $need i32) + (func $assembly/program/Mask#skipBytesToNextInstruction (param $this i32) (param $i i32) (result i32) (local $2 i32) - (local $3 i32) - (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#get:offset - local.get $need + local.get $i + i32.const 1 i32.add local.get $this - local.set $4 + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $2 i32.store offset=4 - local.get $4 - call $assembly/codec/Decoder#get:source - local.set $4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $2 i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i32.lt_u if - global.get $~lib/memory/__stack_pointer - local.get $need - i32.const 10 - call $~lib/number/U32#toString - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/codec/Decoder#get:source - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#get:offset - i32.sub - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=12 - i32.const 14560 - local.set $4 + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 local.get $2 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 14560 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 3 - local.get $3 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 14560 - local.set $4 + local.get $2 + call $assembly/program/Mask#get:bytesToSkip + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $2 i32.store - local.get $4 - i32.const 14400 - local.set $4 + local.get $2 + local.get $i + i32.const 1 + i32.add + call $~lib/staticarray/StaticArray#__get + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 16384 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return end + i32.const 0 + local.set $2 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer + local.get $2 + return ) - (func $assembly/codec/ValOffset#constructor (param $this i32) (param $value i32) (param $offset i32) (result i32) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 40 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end + i32.const 0 + i32.store + local.get $index local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 + i32.store local.get $3 - local.get $value - call $assembly/codec/ValOffset#set:value + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 + i32.store local.get $3 - local.get $offset - call $assembly/codec/ValOffset#set:offset - local.get $this + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer local.get $3 + return ) - (func $assembly/codec/decodeVarU32 (param $data i32) (result i32) - (local $length i32) - (local $first i32) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) (local $3 i32) - (local $4 i32) - (local $msb i32) - (local $number i32) - (local $i i32) - (local $8 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + local.get $index + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - i32.const 1 - global.set $~argumentsLength - global.get $assembly/codec/variableLength - i32.load - call_indirect (type $0) - i32.const 255 - i32.and - local.set $length - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $first - local.get $length - i32.const 0 - i32.eq - if - i32.const 0 - local.get $first - i32.const 1 - call $assembly/codec/ValOffset#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 + local.get $3 i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.get $length - i32.lt_s + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ + i32.ge_u if - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.const 10 - call $~lib/number/I32#toString - local.tee $4 - i32.store offset=8 - i32.const 16608 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $3 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 16608 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 3 - local.get $4 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 16608 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 14400 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 16384 - i32.const 108 - i32.const 5 + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 call $~lib/builtins/abort unreachable end - local.get $first - i32.const 2 - i32.const 8 - local.get $length - i32.sub - call $~lib/math/ipow32 - i32.add + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart + local.get $index i32.const 2 - i32.const 8 - call $~lib/math/ipow32 - i32.sub - local.get $length - i32.const 8 - i32.mul i32.shl - local.set $msb - i32.const 0 - local.set $number - local.get $length - i32.const 1 - i32.sub - local.set $i - loop $for-loop|0 - local.get $i - i32.const 0 - i32.ge_s - if - local.get $number - i32.const 8 - i32.shl - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $i - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.add - local.set $number - local.get $i - i32.const 1 - i32.sub - local.set $i - br $for-loop|0 - end - end - local.get $number - local.get $msb i32.add - local.set $number - i32.const 0 - local.get $number + i32.load + local.tee $value + i32.store offset=4 i32.const 1 - local.get $length - i32.add - call $assembly/codec/ValOffset#constructor - local.set $8 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 14704 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $8 + local.get $3 return ) - (func $assembly/codec/Decoder#varU32 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) + (func $assembly/program/decodeArguments (param $kind i32) (param $data i32) (param $lim i32) (result i32) + (local $extended i32) + (local $i i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -27665,858 +27747,1531 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 + i32.const 0 + i32.store offset=8 + local.get $data + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $5 i32.store - local.get $2 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + global.get $assembly/arguments/REQUIRED_BYTES + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $5 i32.store - local.get $2 - call $assembly/codec/decodeVarU32 - local.tee $v - i32.store offset=12 - local.get $this - local.set $2 + local.get $5 + local.get $kind + call $~lib/array/Array#__get + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/arguments/REQUIRED_BYTES + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $kind + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#constructor + local.tee $extended + i32.store offset=4 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $extended + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $i + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $extended + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $lim + i32.const 2 + global.set $~argumentsLength + global.get $assembly/arguments/DECODERS + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + local.get $kind + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $3) + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $data + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $5 i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/ValOffset#get:offset - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 + local.get $5 + local.get $lim + i32.const 2 + global.set $~argumentsLength + global.get $assembly/arguments/DECODERS + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/ValOffset#get:value - local.set $2 + local.get $5 + i32.store offset=8 + local.get $5 + local.get $kind + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $3) + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $5 return ) - (func $assembly/codec/Decoder#bytes (param $this i32) (param $len i32) (result i32) - (local $v i32) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 i32.store - local.get $3 - local.get $len - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer + local.get $index local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:source - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 i32.store local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $len - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $v - i32.store offset=8 + call $~lib/array/Array#get:length_ + i32.ge_u + if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ + end local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 i32.store local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $len - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/codec/Decoder#remainingBytes (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $value i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - global.set $~argumentsLength i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $v - i32.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/typedarray/Uint8Array#get:length - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 + drop global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 - return ) - (func $assembly/program/CodeAndMetadata#constructor (param $this i32) (param $code i32) (param $metadata i32) (result i32) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 37 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end + i32.store + local.get $index local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 - local.get $3 - local.get $code - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 + i32.store local.get $3 - call $assembly/program/CodeAndMetadata#set:code + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 - local.get $3 - local.get $metadata - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 + i32.store local.get $3 - call $assembly/program/CodeAndMetadata#set:metadata - local.get $this + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop + local.get $value local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer local.get $3 + return ) - (func $assembly/program/extractCodeAndMetadata (param $data i32) (result i32) - (local $decoder i32) - (local $metadataLength i32) - (local $metadata i32) - (local $code i32) - (local $5 i32) + (func $assembly/api-internal/getAssembly (param $p i32) (result i32) + (local $len i32) + (local $v i32) + (local $i i32) + (local $instruction i32) + (local $iData i32) + (local $6 i32) + (local $skipBytes i32) + (local $args i32) + (local $9 i32) + (local $argsArray i32) + (local $relevantArgs i32) + (local $i|12 i32) + (local $13 i32) + (local $14 i32) global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 40 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 20 + i32.const 40 memory.fill + local.get $p + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder + local.get $14 i32.store offset=4 - local.get $decoder - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/codec/Decoder#varU32 - local.set $metadataLength - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $metadataLength - call $assembly/codec/Decoder#bytes - local.tee $metadata - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/codec/Decoder#remainingBytes - local.tee $code - i32.store offset=12 - i32.const 0 - local.get $code - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $metadata - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/program/CodeAndMetadata#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/string/String#concat (param $this i32) (param $other i32) (result i32) - (local $thisSize i32) - (local $otherSize i32) - (local $outSize i32) - (local $out i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $thisSize - local.get $other - local.set $6 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $14 i32.store - local.get $6 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $otherSize - local.get $thisSize - local.get $otherSize - i32.add - local.set $outSize - local.get $outSize + local.get $14 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + local.get $len i32.const 0 i32.eq if i32.const 14400 - local.set $6 + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 40 i32.add global.set $~lib/memory/__stack_pointer - local.get $6 + local.get $14 return end global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $out - local.get $this - local.get $thisSize - memory.copy - local.get $out - local.get $thisSize - i32.add - local.get $other - local.get $otherSize - memory.copy - local.get $out - local.set $6 + i32.const 14480 + local.tee $v + i32.store offset=8 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + call $assembly/program/Mask#isInstruction + i32.eqz + if + i32.const 14512 + i32.const 14624 + i32.const 48 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $instruction + call $~lib/array/Array#__get + end + local.set $iData + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const 14832 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + i32.const 10 + call $~lib/number/I32#toString + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 16640 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/string/String#concat + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $iData + call $assembly/instructions/Instruction#get:namePtr + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $~lib/memory/__stack_pointer + local.get $instruction + i32.const 10 + call $~lib/number/U8#toString + local.tee $6 + i32.store offset=20 + i32.const 16736 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 1 + local.get $6 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 16736 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 14480 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $i + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipBytes + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $p + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + local.get $i + i32.const 1 + i32.add + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $skipBytes + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + i32.const 38 + i32.const 0 + call $~lib/rt/__newArray + local.tee $9 + i32.store offset=28 + local.get $9 + i32.const 0 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:a + call $~lib/array/Array#__set + local.get $9 + i32.const 1 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:b + call $~lib/array/Array#__set + local.get $9 + i32.const 2 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:c + call $~lib/array/Array#__set + local.get $9 + i32.const 3 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/arguments/Args#get:d + call $~lib/array/Array#__set + local.get $9 + local.tee $argsArray + i32.store offset=32 + global.get $assembly/arguments/RELEVANT_ARGS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $iData + call $assembly/instructions/Instruction#get:kind + call $~lib/array/Array#__get + local.set $relevantArgs + i32.const 0 + local.set $i|12 + loop $for-loop|1 + local.get $i|12 + local.get $relevantArgs + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $v + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $~lib/memory/__stack_pointer + local.get $argsArray + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + local.get $i|12 + call $~lib/array/Array#__get + i32.const 10 + call $~lib/number/U32#toString + local.tee $13 + i32.store offset=36 + i32.const 16832 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 1 + local.get $13 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 16832 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + i32.const 14480 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=16 + local.get $14 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/string/String.__concat + local.tee $v + i32.store offset=8 + local.get $i|12 + i32.const 1 + i32.add + local.set $i|12 + br $for-loop|1 + end + end + local.get $i + local.get $skipBytes + i32.add + local.set $i + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $v + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 40 i32.add global.set $~lib/memory/__stack_pointer - local.get $6 + local.get $14 return ) - (func $~lib/string/String.__concat (param $left i32) (param $right i32) (result i32) - (local $2 i32) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $left - local.set $2 + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $3 i32.store - local.get $2 - local.get $right - local.set $2 + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/string/String#concat - local.set $2 + local.get $3 + i32.store + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 - return ) - (func $~lib/string/String#padStart (param $this i32) (param $length i32) (param $pad i32) (result i32) - (local $thisSize i32) - (local $targetSize i32) - (local $padSize i32) - (local $prependSize i32) - (local $out i32) - (local $repeatCount i32) - (local $restBase i32) - (local $restSize i32) - (local $11 i32) + (func $assembly/program-build/skipBytes (param $kind i32) (param $data i32) (result i32) + (local $2 i32) + (local $n i32) + (local $split i32) + (local $n|5 i32) + (local $split|6 i32) + (local $n|7 i32) + (local $split|8 i32) + (local $value1 f64) + (local $value2 f64) + (local $value1|11 f64) + (local $value2|12 f64) + (local $n|13 i32) + (local $split|14 i32) + (local $15 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 24 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $thisSize - local.get $length - i32.const 1 - i32.shl - local.set $targetSize - local.get $pad - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $padSize - local.get $targetSize - local.get $thisSize - i32.lt_u - if (result i32) - i32.const 1 - else - local.get $padSize - i32.eqz - end - if - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $targetSize - local.get $thisSize - i32.sub - local.set $prependSize - global.get $~lib/memory/__stack_pointer - local.get $targetSize - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $prependSize - local.get $padSize - i32.gt_u - if - local.get $prependSize + i32.const 0 + i32.const 24 + memory.fill + block $case13|0 + block $case12|0 + block $case11|0 + block $case10|0 + block $case9|0 + block $case8|0 + block $case7|0 + block $case6|0 + block $case5|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $kind + local.set $2 + local.get $2 + global.get $assembly/arguments/Arguments.Zero + i32.eq + br_if $case0|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneImm + i32.eq + br_if $case1|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoImm + i32.eq + br_if $case2|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneOff + i32.eq + br_if $case3|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegOneImm + i32.eq + br_if $case4|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegOneExtImm + i32.eq + br_if $case5|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i32.eq + br_if $case6|0 + local.get $2 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i32.eq + br_if $case7|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoReg + i32.eq + br_if $case8|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i32.eq + br_if $case9|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i32.eq + br_if $case10|0 + local.get $2 + global.get $assembly/arguments/Arguments.TwoRegTwoImm + i32.eq + br_if $case11|0 + local.get $2 + global.get $assembly/arguments/Arguments.ThreeReg + i32.eq + br_if $case12|0 + br $case13|0 + end + i32.const 0 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + call $assembly/program-build/immBytes + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n + i32.store offset=4 + local.get $n + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:low + i32.const 1 + i32.add + local.set $split + i32.const 1 + local.get $split + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + local.get $split + i32.const 1 + i32.add + i32.const 255 + i32.and + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + call $assembly/program-build/immBytes + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 9 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n|5 + i32.store offset=8 + local.get $n|5 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:hig + i32.const 1 + i32.add + local.set $split|6 + i32.const 1 + local.get $split|6 + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + local.get $split|6 + i32.const 255 + i32.and + i32.add + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n|7 + i32.store offset=12 + local.get $n|7 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:hig + i32.const 1 + i32.add + local.set $split|8 + i32.const 1 + local.get $split|8 + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + local.get $split|8 + i32.const 255 + i32.and + i32.add + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + block $~lib/math/NativeMath.min|inlined.5 (result f64) + f64.const 4 + local.set $value1 + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + local.set $value2 + local.get $value1 + local.get $value2 + f64.min + br $~lib/math/NativeMath.min|inlined.5 + end + i32.trunc_sat_f64_s + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + i32.const 1 + block $~lib/math/NativeMath.min|inlined.6 (result f64) + f64.const 4 + local.set $value1|11 + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + local.set $value2|12 + local.get $value1|11 + local.get $value2|12 + f64.min + br $~lib/math/NativeMath.min|inlined.6 + end + i32.trunc_sat_f64_s + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $n|13 + i32.store offset=16 + local.get $n|13 + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $assembly/arguments/Nibbles#get:low + i32.const 1 + i32.add + local.set $split|14 + i32.const 2 + local.get $split|14 + i32.const 255 + i32.and + i32.add + local.get $data + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store + local.get $15 + call $~lib/typedarray/Uint8Array#get:length + i32.const 2 + local.get $split|14 + i32.const 255 + i32.and + i32.add + call $assembly/program-build/immBytes + i32.add + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $15 + return + end i32.const 2 - i32.sub - local.get $padSize - i32.div_u - local.set $repeatCount - local.get $repeatCount - local.get $padSize - i32.mul - local.set $restBase - local.get $prependSize - local.get $restBase - i32.sub - local.set $restSize - local.get $out - local.get $pad - local.get $padSize - local.get $repeatCount - call $~lib/memory/memory.repeat - local.get $out - local.get $restBase + local.set $15 + global.get $~lib/memory/__stack_pointer + i32.const 24 i32.add - local.get $pad - local.get $restSize - memory.copy - else - local.get $out - local.get $pad - local.get $prependSize - memory.copy + global.set $~lib/memory/__stack_pointer + local.get $15 + return end - local.get $out - local.get $prependSize - i32.add - local.get $this - local.get $thisSize - memory.copy - local.get $out - local.set $11 + i32.const 16864 + local.set $15 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return + local.get $15 + i32.store + local.get $15 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $15 + global.get $~lib/memory/__stack_pointer + local.get $15 + i32.store offset=20 + local.get $15 + call $~lib/string/String#concat + i32.const 16944 + i32.const 73 + i32.const 7 + call $~lib/builtins/abort + unreachable ) - (func $assembly/index/disassemble~anonymous|0 (param $acc i32) (param $x i32) (param $$2 i32) (param $$3 i32) (result i32) - (local $4 i32) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $acc - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 + i32.const 0 i32.store - local.get $4 - local.get $x - i32.const 16 - call $~lib/number/U8#toString - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - i32.const 2 - i32.const 14800 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $~lib/string/String#padStart - local.set $4 + local.get $index + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/string/String.__concat - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 + local.get $3 + i32.store + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 0 + i32.shl i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#reduce<~lib/string/String> (param $this i32) (param $fn i32) (param $initialValue i32) (result i32) - (local $array i32) - (local $fn|4 i32) - (local $initialValue|5 i32) - (local $ptr i32) - (local $i i32) - (local $k i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer + i32.load8_u + local.set $value i32.const 0 - i32.const 20 - memory.fill - block $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $array - i32.store - global.get $~lib/memory/__stack_pointer - local.get $fn - local.tee $fn|4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $initialValue - local.tee $initialValue|5 - i32.store offset=8 - local.get $array - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.set $ptr - i32.const 0 - local.set $i - local.get $array - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.set $k - loop $for-loop|0 - local.get $i - local.get $k - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $initialValue|5 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - local.get $ptr - local.get $i - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.get $i - local.get $array - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 4 - global.set $~argumentsLength - local.get $fn|4 - i32.load - call_indirect (type $5) - local.tee $initialValue|5 - i32.store offset=8 - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $initialValue|5 - br $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" - end - local.set $9 + drop + local.get $value + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $9 + local.get $3 return ) - (func $assembly/codec/Decoder#u8 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 + i32.const 0 i32.store - local.get $2 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $4 i32.store - local.get $2 + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v + local.get $len + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 0 + drop local.get $this - local.set $2 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $4 i32.store - local.get $2 + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 local.get $this - local.set $2 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $4 return ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) + (func $assembly/program-build/buildMask (param $bytecode i32) (result i32) + (local $mask i32) + (local $i i32) + (local $instruction i32) + (local $iData i32) + (local $requiredBytes i32) + (local $6 i32) + (local $packed i32) + (local $i|8 i32) + (local $byte i32) + (local $j i32) + (local $11 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 + local.get $bytecode + local.set $11 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $11 i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + call $~lib/staticarray/StaticArray#constructor + local.tee $mask + i32.store offset=4 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/array/Array#get:length + i32.lt_s + if (result i32) + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $instruction + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $iData + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $i + i32.const 1 + call $~lib/staticarray/StaticArray#__set + global.get $assembly/arguments/REQUIRED_BYTES + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $iData + call $assembly/instructions/Instruction#get:kind + call $~lib/array/Array#__get + local.set $requiredBytes + local.get $i + i32.const 1 + i32.add + local.get $requiredBytes + i32.add + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + i32.le_s + if + local.get $i + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $bytecode + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + local.get $i + i32.const 1 + i32.add + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $assembly/program-build/skipBytes + i32.add + local.set $i + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end end - local.get $this - local.set $3 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 17024 + call $~lib/rt/__newArray + local.tee $packed + i32.store offset=12 + i32.const 0 + local.set $i|8 + loop $for-loop|1 + local.get $i|8 + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + i32.const 0 + local.set $byte + local.get $i|8 + local.set $j + loop $for-loop|3 + local.get $j + local.get $i|8 + i32.const 8 + i32.add + i32.lt_s + if + local.get $byte + i32.const 255 + i32.and + i32.const 1 + i32.const 7 + i32.and + i32.shr_u + local.set $byte + local.get $j + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if (result i32) + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $j + call $~lib/staticarray/StaticArray#__get + else + i32.const 0 + end + if + local.get $byte + i32.const 128 + i32.or + local.set $byte + end + local.get $j + i32.const 1 + i32.add + local.set $j + br $for-loop|3 + end + end + local.get $packed + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + local.get $byte + call $~lib/array/Array#push + drop + local.get $i|8 + i32.const 8 + i32.add + local.set $i|8 + br $for-loop|1 + end + end + local.get $packed + local.set $11 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer + local.get $11 + return ) - (func $assembly/program/Mask#constructor (param $this i32) (param $packedMask i32) (param $codeLength i32) (result i32) - (local $lastInstructionOffset i32) - (local $i i32) - (local $bits i32) - (local $index i32) - (local $b i32) - (local $isSet i32) - (local $9 i32) + (func $~lib/dataview/DataView#constructor (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) + (local $dataStart i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub @@ -28532,368 +29287,157 @@ i32.eqz if global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 31 + i32.const 12 + i32.const 40 call $~lib/rt/itcms/__new local.tee $this i32.store end local.get $this - local.set $9 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $5 i32.store offset=4 - local.get $9 + local.get $5 i32.const 0 - call $assembly/program/Mask#set:bytesToSkip + call $~lib/dataview/DataView#set:buffer local.get $this - local.set $9 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $5 i32.store offset=4 - local.get $9 - i32.const 0 - local.get $codeLength - call $~lib/staticarray/StaticArray#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/Mask#set:bytesToSkip + local.get $5 i32.const 0 - local.set $lastInstructionOffset - local.get $packedMask - local.set $9 + call $~lib/dataview/DataView#set:dataStart + local.get $this + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $5 i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.sub - local.set $i - loop $for-loop|0 - local.get $i - i32.const 0 - i32.ge_s - if - local.get $packedMask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $bits - local.get $i - i32.const 8 - i32.mul - local.set $index - i32.const 7 - local.set $b - loop $for-loop|2 - local.get $b - i32.const 0 - i32.ge_s - if - local.get $bits - i32.const 128 - i32.and - local.set $isSet - local.get $bits - i32.const 1 - i32.const 7 - i32.and - i32.shl - local.set $bits - local.get $index - local.get $b - i32.add - local.get $codeLength - i32.lt_s - if - local.get $isSet - if (result i32) - i32.const 0 - else - local.get $lastInstructionOffset - i32.const 1 - i32.add - end - local.set $lastInstructionOffset - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/Mask#get:bytesToSkip - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $index - local.get $b - i32.add - local.get $lastInstructionOffset - global.get $assembly/program/MAX_SKIP - i32.const 1 - i32.add - i32.lt_u - if (result i32) - local.get $lastInstructionOffset - else - global.get $assembly/program/MAX_SKIP - i32.const 1 - i32.add - end - call $~lib/staticarray/StaticArray#__set - end - local.get $b - i32.const 1 - i32.sub - local.set $b - br $for-loop|2 - end - end - local.get $i - i32.const 1 - i32.sub - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 12 + local.get $5 + i32.const 0 + call $~lib/dataview/DataView#set:byteLength + local.get $byteLength + i32.const 1073741820 + i32.gt_u + local.get $byteOffset + local.get $byteLength i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - ) - (func $assembly/program/JumpTable#constructor (param $this i32) (param $itemBytes i32) (param $data i32) (result i32) - (local $jumps i32) - (local $i i32) - (local $num i64) - (local $j i32) - (local $nextNum i64) - (local $isOverflow i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + local.get $buffer + local.set $5 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/arraybuffer/ArrayBuffer#get:byteLength + i32.gt_u + i32.or if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 33 - call $~lib/rt/itcms/__new - local.tee $this - i32.store + i32.const 8176 + i32.const 17056 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable end local.get $this - local.set $9 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $5 i32.store offset=4 - local.get $9 - i32.const 0 - call $assembly/program/JumpTable#set:jumps + local.get $5 + local.get $buffer + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $itemBytes - i32.const 255 - i32.and - i32.const 0 - i32.gt_u - if (result i32) - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.get $itemBytes - i32.const 255 - i32.and - i32.div_s - else - i32.const 0 - end - call $~lib/staticarray/StaticArray#constructor - local.tee $jumps + local.get $5 i32.store offset=8 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - i64.const 0 - local.set $num - local.get $itemBytes - i32.const 1 - i32.sub - i32.const 255 - i32.and - local.set $j - loop $for-loop|1 - local.get $j - i32.const 0 - i32.ge_s - if - local.get $num - i64.const 8 - i64.shl - local.set $nextNum - local.get $nextNum - local.get $num - i64.lt_u - local.set $isOverflow - local.get $nextNum - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - local.get $j - i32.add - call $~lib/typedarray/Uint8Array#__get - i64.extend_i32_u - i64.add - local.set $nextNum - local.get $isOverflow - if (result i32) - i32.const 1 - else - local.get $nextNum - local.get $num - i64.lt_u - end - local.set $isOverflow - local.get $isOverflow - if (result i64) - global.get $~lib/builtins/u64.MAX_VALUE - else - local.get $nextNum - end - local.set $num - local.get $j - i32.const 1 - i32.sub - local.set $j - br $for-loop|1 - end - end - local.get $jumps - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - local.get $itemBytes - i32.const 255 - i32.and - i32.div_s - local.get $num - call $~lib/staticarray/StaticArray#__set - local.get $i - local.get $itemBytes - i32.const 255 - i32.and - i32.add - local.set $i - br $for-loop|0 - end - end + local.get $5 + call $~lib/dataview/DataView#set:buffer + local.get $buffer + local.get $byteOffset + i32.add + local.set $dataStart local.get $this - local.set $9 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $5 i32.store offset=4 - local.get $9 - local.get $jumps - local.set $9 + local.get $5 + local.get $dataStart + call $~lib/dataview/DataView#set:dataStart + local.get $this + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $assembly/program/JumpTable#set:jumps + local.get $5 + i32.store offset=4 + local.get $5 + local.get $byteLength + call $~lib/dataview/DataView#set:byteLength local.get $this - local.set $9 + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $9 + local.get $5 ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) + (func $~lib/dataview/DataView#constructor@varargs (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable + i64.const 0 + i64.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of2 $1of2 $2of2 $outOfRange + end + unreachable + end + i32.const 0 + local.set $byteOffset + end + local.get $buffer + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/arraybuffer/ArrayBuffer#get:byteLength + local.set $byteLength end local.get $this - local.set $3 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $4 i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset + local.get $4 + local.get $buffer + local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $4 + i32.store offset=4 + local.get $4 + local.get $byteOffset + local.get $byteLength + call $~lib/dataview/DataView#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer + local.get $4 ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) + (func $~lib/dataview/DataView#setUint64 (param $this i32) (param $byteOffset i32) (param $value i64) (param $littleEndian i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub @@ -28902,883 +29446,657 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store - local.get $index + local.get $byteOffset + i32.const 31 + i32.shr_u + local.get $byteOffset + i32.const 8 + i32.add local.get $this - local.set $3 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $4 i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u + local.get $4 + call $~lib/dataview/DataView#get:byteLength + i32.gt_s + i32.or if i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 + i32.const 17056 + i32.const 174 + i32.const 7 call $~lib/builtins/abort unreachable end local.get $this - local.get $index - i32.const 2 - i32.shl + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/dataview/DataView#get:dataStart + local.get $byteOffset i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 + local.get $littleEndian + if (result i64) + local.get $value + else + local.get $value + call $~lib/polyfills/bswap + end + i64.store global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 - return ) - (func $assembly/program/Mask#isInstruction (param $this i32) (param $index i32) (result i32) - (local $2 i32) + (func $assembly/codec/encodeVarU32 (param $v i64) (result i32) + (local $maxEncoded i64) + (local $dest i32) + (local $dataView i32) + (local $minEncoded i64) + (local $l i32) + (local $dest|6 i32) + (local $maxVal i32) + (local $byte i64) + (local $rest i64) + (local $i i32) + (local $11 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + local.get $v i64.const 0 - i64.store - local.get $index - i64.extend_i32_u - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i64.extend_i32_s - i64.ge_u + i64.eq if i32.const 0 - local.set $2 + i32.const 1 + call $~lib/typedarray/Uint8Array#constructor + local.set $11 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $11 return end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $index - call $~lib/staticarray/StaticArray#__get - i32.const 0 - i32.eq - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/program/Mask#skipBytesToNextInstruction (param $this i32) (param $i i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $i - i32.const 1 - i32.add - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i32.lt_u + i64.const 2 + i64.const 7 + i64.const 8 + i64.mul + call $~lib/math/ipow64 + local.set $maxEncoded + local.get $v + local.get $maxEncoded + i64.ge_u if - local.get $this - local.set $2 global.get $~lib/memory/__stack_pointer - local.get $2 + i32.const 0 + i32.const 9 + call $~lib/typedarray/Uint8Array#constructor + local.tee $dest + i32.store + local.get $dest + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 + local.get $11 + i32.const 0 + i32.const 255 + call $~lib/typedarray/Uint8Array#__set global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $i + i32.const 0 + local.get $dest + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $~lib/arraybuffer/ArrayBufferView#get:buffer + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 i32.const 1 - i32.add - call $~lib/staticarray/StaticArray#__get - local.set $2 + global.set $~argumentsLength + i32.const 0 + call $~lib/dataview/DataView#constructor@varargs + local.tee $dataView + i32.store offset=12 + local.get $dataView + local.set $11 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 1 + local.get $v + i32.const 1 + call $~lib/dataview/DataView#setUint64 + local.get $dest + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $11 return end - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/BasicBlocks#constructor (param $this i32) (param $code i32) (param $mask i32) (result i32) - (local $len i32) - (local $isStartOrEnd i32) - (local $n i32) - (local $isInstructionInMask i32) - (local $skipArgs i32) - (local $iData i32) - (local $isTerminating i32) - (local $newBlockStart i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 34 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - call $assembly/program/BasicBlocks#set:isStartOrEnd - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $len - call $~lib/staticarray/StaticArray#constructor - local.tee $isStartOrEnd - i32.store offset=8 - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set - i32.const 0 - local.set $n + local.get $maxEncoded + i64.const 7 + i64.shr_u + local.set $minEncoded + i32.const 7 + local.set $l loop $for-loop|0 - local.get $n - local.get $len - i32.lt_s + local.get $l + i32.const 0 + i32.ge_s if - block $for-continue|0 - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $assembly/program/Mask#isInstruction - local.set $isInstructionInMask - local.get $isInstructionInMask - i32.eqz - if - br $for-continue|0 - end - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipArgs - local.get $code - local.set $11 + local.get $v + local.get $minEncoded + i64.ge_u + if global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - global.get $assembly/instructions/INSTRUCTIONS + i32.const 0 + local.get $l + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $dest|6 + i32.store offset=16 + i32.const 2 + i32.const 8 + local.get $l + i32.mul + call $~lib/math/ipow32 + local.set $maxVal + i32.const 2 + i32.const 8 + call $~lib/math/ipow32 + i32.const 2 + i32.const 8 + local.get $l + i32.sub + call $~lib/math/ipow32 + i32.sub + i64.extend_i32_s + local.get $v + local.get $maxVal + i64.extend_i32_s + i64.div_u + i64.add + local.set $byte + local.get $dest|6 local.set $11 global.get $~lib/memory/__stack_pointer local.get $11 i32.store offset=4 local.get $11 - call $~lib/array/Array#get:length + i32.const 0 + local.get $byte + i32.wrap_i64 i32.const 255 i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#__get - end - local.set $iData - local.get $iData - call $assembly/instructions/Instruction#get:isTerminating - local.set $isTerminating - local.get $isTerminating - if - local.get $n + call $~lib/typedarray/Uint8Array#__set + local.get $v + local.get $maxVal + i64.extend_i32_s + i64.rem_u + local.set $rest + i32.const 1 + local.set $i + loop $for-loop|1 + local.get $i i32.const 1 + local.get $l i32.add - local.get $skipArgs - i32.add - local.set $newBlockStart - local.get $newBlockStart - local.get $len i32.lt_s if - local.get $isStartOrEnd + local.get $dest|6 local.set $11 global.get $~lib/memory/__stack_pointer local.get $11 i32.store offset=4 local.get $11 - local.get $newBlockStart - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set + local.get $i + local.get $rest + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $rest + i64.const 8 + i64.shr_u + local.set $rest + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|1 end - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - local.get $n - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.END - i32.or - call $~lib/staticarray/StaticArray#__set end + local.get $dest|6 + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return end - local.get $n + local.get $minEncoded + local.set $maxEncoded + local.get $minEncoded + i64.const 7 + i64.shr_u + local.set $minEncoded + local.get $l i32.const 1 - i32.add - local.set $n + i32.sub + local.set $l br $for-loop|0 end end - local.get $this + i32.const 17120 local.set $11 global.get $~lib/memory/__stack_pointer local.get $11 i32.store offset=4 local.get $11 - local.get $isStartOrEnd + local.get $v + i32.const 10 + call $~lib/number/U64#toString local.set $11 global.get $~lib/memory/__stack_pointer local.get $11 - i32.store offset=12 - local.get $11 - call $assembly/program/BasicBlocks#set:isStartOrEnd - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer + i32.store offset=8 local.get $11 + call $~lib/string/String#concat + i32.const 17200 + i32.const 160 + i32.const 3 + call $~lib/builtins/abort + unreachable ) - (func $assembly/program/Program#constructor (param $this i32) (param $code i32) (param $mask i32) (param $jumpTable i32) (param $basicBlocks i32) (result i32) - (local $5 i32) + (func $assembly/program-build/wrapAsProgram (param $bytecode i32) (result i32) + (local $codeLength i32) + (local $mask i32) + (local $codeLengthBytes i32) + (local $data i32) + (local $offset i32) + (local $i i32) + (local $i|7 i32) + (local $i|8 i32) + (local $9 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 30 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $code - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:code - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:mask - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:jumpTable - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:basicBlocks - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/program/deblob (param $program i32) (result i32) - (local $decoder i32) - (local $jumpTableLength i32) - (local $jumpTableItemLength i32) - (local $codeLength i32) - (local $jumpTableLengthInBytes i32) - (local $rawJumpTable i32) - (local $rawCode i32) - (local $rawMask i32) - (local $mask i32) - (local $jumpTable i32) - (local $basicBlocks i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 44 + i32.const 20 memory.fill + local.get $bytecode + local.set $9 global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $program - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=4 - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#varU32 - local.set $jumpTableLength - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#u8 - local.set $jumpTableItemLength - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $9 i32.store - local.get $12 - call $assembly/codec/Decoder#varU32 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length local.set $codeLength - local.get $jumpTableLength - local.get $jumpTableItemLength - i32.mul - local.set $jumpTableLengthInBytes global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 + local.get $bytecode + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $9 i32.store - local.get $12 - local.get $jumpTableLengthInBytes - call $assembly/codec/Decoder#bytes - local.tee $rawJumpTable - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 + local.get $9 + call $assembly/program-build/buildMask + local.tee $mask + i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 local.get $codeLength - call $assembly/codec/Decoder#bytes - local.tee $rawCode - i32.store offset=12 + i64.extend_i32_s + call $assembly/codec/encodeVarU32 + local.tee $codeLengthBytes + i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 + i32.const 0 + i32.const 1 + i32.const 1 + i32.add + local.get $codeLengthBytes + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $9 i32.store - local.get $12 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.add local.get $codeLength - i32.const 7 i32.add - i32.const 8 - i32.div_u - call $assembly/codec/Decoder#bytes - local.tee $rawMask - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $rawMask - local.set $12 + local.get $mask + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $9 i32.store - local.get $12 - local.get $codeLength - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $jumpTableItemLength - local.get $rawJumpTable - local.set $12 + local.get $9 + call $~lib/array/Array#get:length + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $data + i32.store offset=12 + local.get $data + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $9 i32.store - local.get $12 - call $assembly/program/JumpTable#constructor - local.tee $jumpTable - i32.store offset=24 - global.get $~lib/memory/__stack_pointer + local.get $9 i32.const 0 - local.get $rawCode - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $mask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - call $assembly/program/BasicBlocks#constructor - local.tee $basicBlocks - i32.store offset=32 i32.const 0 - local.get $rawCode - local.set $12 + call $~lib/typedarray/Uint8Array#__set + local.get $data + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $9 i32.store - local.get $12 - local.get $mask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - local.get $jumpTable - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=36 - local.get $12 - local.get $basicBlocks - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=40 - local.get $12 - call $assembly/program/Program#constructor - local.set $12 + local.get $9 + i32.const 1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + i32.const 2 + local.set $offset + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $codeLengthBytes + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $offset + local.get $codeLengthBytes + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $offset + i32.const 1 + i32.add + local.set $offset + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|7 + loop $for-loop|1 + local.get $i|7 + local.get $bytecode + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $offset + local.get $bytecode + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + local.get $i|7 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $offset + i32.const 1 + i32.add + local.set $offset + local.get $i|7 + i32.const 1 + i32.add + local.set $i|7 + br $for-loop|1 + end + end + i32.const 0 + local.set $i|8 + loop $for-loop|2 + local.get $i|8 + local.get $mask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/array/Array#get:length + i32.lt_s + if + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $offset + local.get $mask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + local.get $i|8 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $offset + i32.const 1 + i32.add + local.set $offset + local.get $i|8 + i32.const 1 + i32.add + local.set $i|8 + br $for-loop|2 + end + end + local.get $data + local.set $9 global.get $~lib/memory/__stack_pointer - i32.const 44 + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer - local.get $12 + local.get $9 return ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) + (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) + (local $target i32) + (local $source|4 i32) + (local $offset|5 i32) + (local $sourceLen i32) + (local $targetStart i32) + (local $sourceStart i32) + (local $9 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $this + local.tee $target i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u + global.get $~lib/memory/__stack_pointer + local.get $source + local.tee $source|4 + i32.store offset=4 + local.get $offset + local.set $offset|5 + i32.const 0 + drop + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/array/Array#get:length + local.set $sourceLen + local.get $offset|5 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + local.get $sourceLen + local.get $offset|5 + i32.add + local.get $target + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s + end if i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 + i32.const 720 + i32.const 1902 + i32.const 5 call $~lib/builtins/abort unreachable end - local.get $this - local.set $3 + local.get $target + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.get $offset|5 + i32.const 0 i32.shl i32.add - i32.load - local.set $value + local.set $targetStart + local.get $source|4 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $~lib/array/Array#get:dataStart + local.set $sourceStart i32.const 0 + i32.eqz drop - local.get $value - local.set $3 + local.get $targetStart + local.get $sourceStart + local.get $sourceLen + i32.const 0 + i32.shl + memory.copy global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 - return ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) + (func $assembly/program/liftBytes (param $data i32) (result i32) + (local $p i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $index - local.get $this - local.set $3 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 + i32.const 0 + local.get $data + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $2 i32.store - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value + local.get $2 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $p i32.store offset=4 - i32.const 1 - drop + local.get $p + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $data + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 + call $~lib/typedarray/Uint8Array#set<~lib/array/Array> + local.get $p + local.set $2 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $2 return ) - (func $assembly/program/decodeArguments (param $kind i32) (param $data i32) (param $lim i32) (result i32) - (local $extended i32) - (local $i i32) - (local $5 i32) + (func $assembly/codec/Decoder#constructor (param $this i32) (param $source i32) (param $offset i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub @@ -29790,727 +30108,470 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - global.get $assembly/arguments/REQUIRED_BYTES - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $kind - call $~lib/array/Array#__get - i32.lt_s + local.get $this + i32.eqz if global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/arguments/REQUIRED_BYTES - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $kind - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#constructor - local.tee $extended - i32.store offset=4 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $extended - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $extended - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 + i32.const 8 + i32.const 42 + call $~lib/rt/itcms/__new + local.tee $this i32.store - local.get $5 - local.get $lim - i32.const 2 - global.set $~argumentsLength - global.get $assembly/arguments/DECODERS - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $kind - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $3) - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return end - local.get $data - local.set $5 + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $lim - i32.const 2 - global.set $~argumentsLength - global.get $assembly/arguments/DECODERS - local.set $5 + local.get $3 + i32.store offset=4 + local.get $3 + local.get $source + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $3 i32.store offset=8 - local.get $5 - local.get $kind - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $3) - local.set $5 + local.get $3 + call $assembly/codec/Decoder#set:source + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $offset + call $assembly/codec/Decoder#set:offset + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 - return + local.get $3 ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (func $assembly/codec/Decoder#ensureBytes (param $this i32) (param $need i32) + (local $2 i32) (local $3 i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 i32.store - local.get $index + local.get $4 + call $assembly/codec/Decoder#get:offset + local.get $need + i32.add local.get $this - local.set $3 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/codec/Decoder#get:source + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + i32.gt_s if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end + global.get $~lib/memory/__stack_pointer + local.get $need + i32.const 10 + call $~lib/number/U32#toString + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/codec/Decoder#get:source + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length local.get $this - local.set $3 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $4 i32.store - local.get $3 - local.get $index + local.get $4 + call $assembly/codec/Decoder#get:offset + i32.sub + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=12 + i32.const 17392 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 i32.const 1 - i32.add - call $~lib/array/Array#set:length_ + local.get $2 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 17392 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 3 + local.get $3 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 17392 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 14480 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 17200 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) + (func $assembly/codec/ValOffset#constructor (param $this i32) (param $value i32) (param $offset i32) (result i32) (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 43 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store + i32.store offset=4 local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end + local.get $value + call $assembly/codec/ValOffset#set:value local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store + i32.store offset=4 local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value + local.get $offset + call $assembly/codec/ValOffset#set:offset + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer local.get $3 - return ) - (func $assembly/api-generic/getAssembly (param $p i32) (result i32) - (local $len i32) - (local $v i32) + (func $assembly/codec/decodeVarU32 (param $data i32) (result i32) + (local $length i32) + (local $first i32) + (local $3 i32) + (local $4 i32) + (local $msb i32) + (local $number i32) (local $i i32) - (local $instruction i32) - (local $iData i32) - (local $6 i32) - (local $skipBytes i32) - (local $args i32) - (local $9 i32) - (local $argsArray i32) - (local $relevantArgs i32) - (local $i|12 i32) - (local $13 i32) - (local $14 i32) + (local $8 i32) global.get $~lib/memory/__stack_pointer - i32.const 40 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $p - local.set $14 + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 + i64.const 0 + i64.store offset=8 + local.get $data + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $8 i32.store - local.get $14 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - local.get $len + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + i32.const 1 + global.set $~argumentsLength + global.get $assembly/codec/variableLength + i32.load + call_indirect (type $0) + i32.const 255 + i32.and + local.set $length + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + local.set $first + local.get $length i32.const 0 i32.eq if - i32.const 16928 - local.set $14 + i32.const 0 + local.get $first + i32.const 1 + call $assembly/codec/ValOffset#constructor + local.set $8 global.get $~lib/memory/__stack_pointer - i32.const 40 + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $14 + local.get $8 return end + local.get $data + local.set $8 global.get $~lib/memory/__stack_pointer - i32.const 14400 - local.tee $v - i32.store offset=8 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - call $assembly/program/Mask#isInstruction - i32.eqz - if - i32.const 17008 - i32.const 17120 - i32.const 46 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $instruction - call $~lib/array/Array#__get - end - local.set $iData - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const 17200 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - i32.const 10 - call $~lib/number/I32#toString - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 17232 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/string/String#concat - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $iData - call $assembly/instructions/Instruction#get:namePtr - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.get $length + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + i32.const 10 + call $~lib/number/I32#toString + local.tee $4 + i32.store offset=8 + i32.const 17600 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + local.get $3 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 17600 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 3 + local.get $4 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 17600 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 14480 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 17200 + i32.const 108 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $first + i32.const 2 + i32.const 8 + local.get $length + i32.sub + call $~lib/math/ipow32 + i32.add + i32.const 2 + i32.const 8 + call $~lib/math/ipow32 + i32.sub + local.get $length + i32.const 8 + i32.mul + i32.shl + local.set $msb + i32.const 0 + local.set $number + local.get $length + i32.const 1 + i32.sub + local.set $i + loop $for-loop|0 + local.get $i + i32.const 0 + i32.ge_s + if + local.get $number + i32.const 8 + i32.shl + local.get $data + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $8 i32.store - local.get $14 - global.get $~lib/memory/__stack_pointer - local.get $instruction - i32.const 10 - call $~lib/number/U8#toString - local.tee $6 - i32.store offset=20 - i32.const 17328 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 + local.get $8 i32.const 1 - local.get $6 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 17328 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 14400 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipBytes - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 local.get $i - i32.const 1 i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $skipBytes - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - i32.const 42 - i32.const 0 - call $~lib/rt/__newArray - local.tee $9 - i32.store offset=28 - local.get $9 - i32.const 0 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:a - call $~lib/array/Array#__set - local.get $9 - i32.const 1 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:b - call $~lib/array/Array#__set - local.get $9 - i32.const 2 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:c - call $~lib/array/Array#__set - local.get $9 - i32.const 3 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:d - call $~lib/array/Array#__set - local.get $9 - local.tee $argsArray - i32.store offset=32 - global.get $assembly/arguments/RELEVANT_ARGS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $iData - call $assembly/instructions/Instruction#get:kind - call $~lib/array/Array#__get - local.set $relevantArgs - i32.const 0 - local.set $i|12 - loop $for-loop|1 - local.get $i|12 - local.get $relevantArgs - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $~lib/memory/__stack_pointer - local.get $argsArray - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - local.get $i|12 - call $~lib/array/Array#__get - i32.const 10 - call $~lib/number/U32#toString - local.tee $13 - i32.store offset=36 - i32.const 17424 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 1 - local.get $13 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 17424 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 14400 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - local.get $i|12 - i32.const 1 - i32.add - local.set $i|12 - br $for-loop|1 - end - end - local.get $i - local.get $skipBytes + call $~lib/typedarray/Uint8Array#__get i32.add - local.set $i + local.set $number local.get $i i32.const 1 - i32.add + i32.sub local.set $i br $for-loop|0 end end - local.get $v - local.set $14 + local.get $number + local.get $msb + i32.add + local.set $number + i32.const 0 + local.get $number + i32.const 1 + local.get $length + i32.add + call $assembly/codec/ValOffset#constructor + local.set $8 global.get $~lib/memory/__stack_pointer - i32.const 40 + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $14 + local.get $8 return ) - (func $assembly/codec/Decoder#u24 (param $this i32) (result i32) + (func $assembly/codec/Decoder#varU32 (param $this i32) (result i32) (local $v i32) (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 local.get $this local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 i32.store local.get $2 - i32.const 3 + i32.const 1 call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer local.get $this local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=4 + i32.store offset=8 local.get $2 call $assembly/codec/Decoder#get:source local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 - i32.store + i32.store offset=4 local.get $2 local.get $this local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=4 + i32.store offset=8 local.get $2 call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=4 + i32.store local.get $2 - call $assembly/codec/Decoder#get:source + call $assembly/codec/decodeVarU32 + local.tee $v + i32.store offset=12 + local.get $this local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 @@ -30523,50 +30584,419 @@ i32.store offset=4 local.get $2 call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $v local.get $v - local.get $this local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 i32.store offset=4 local.get $2 - call $assembly/codec/Decoder#get:source + call $assembly/codec/ValOffset#get:offset + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 i32.store local.get $2 - local.get $this + call $assembly/codec/ValOffset#get:value local.set $2 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get i32.const 16 - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store + i32.add + global.set $~lib/memory/__stack_pointer local.get $2 - local.get $this - local.set $2 + return + ) + (func $assembly/codec/Decoder#bytes (param $this i32) (param $len i32) (result i32) + (local $v i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - local.get $2 + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $len + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:source + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $len + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $v + i32.store offset=8 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/codec/Decoder#get:offset + local.get $len + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/codec/Decoder#remainingBytes (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $v + i32.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/typedarray/Uint8Array#get:length + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/program/CodeAndMetadata#constructor (param $this i32) (param $code i32) (param $metadata i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 41 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $code + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/program/CodeAndMetadata#set:code + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $metadata + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/program/CodeAndMetadata#set:metadata + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/program/extractCodeAndMetadata (param $data i32) (result i32) + (local $decoder i32) + (local $metadataLength i32) + (local $metadata i32) + (local $code i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/codec/Decoder#varU32 + local.set $metadataLength + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $metadataLength + call $assembly/codec/Decoder#bytes + local.tee $metadata + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/codec/Decoder#remainingBytes + local.tee $code + i32.store offset=12 + i32.const 0 + local.get $code + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $metadata + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/program/CodeAndMetadata#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/codec/Decoder#u24 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 3 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + local.set $v + local.get $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or + local.set $v + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 i32.store offset=4 local.get $2 call $assembly/codec/Decoder#get:offset @@ -30883,7 +31313,7 @@ call $assembly/codec/Decoder#isExhausted i32.eqz if - i32.const 17456 + i32.const 17904 local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 @@ -30918,7 +31348,7 @@ i32.store offset=4 local.get $1 call $~lib/string/String#concat - i32.const 16384 + i32.const 17200 i32.const 31 i32.const 7 call $~lib/builtins/abort @@ -30929,375 +31359,285 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/program/decodeSpi (param $data i32) (result i32) - (local $decoder i32) - (local $roLength i32) - (local $rwLength i32) - (local $_heapPages i32) - (local $_stackSize i32) - (local $_roMem i32) - (local $_rwMem i32) - (local $codeLength i32) - (local $code i32) - (local $10 i32) + (func $assembly/codec/Decoder#u8 (param $this i32) (result i32) + (local $v i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $10 + i64.const 0 + i64.store + local.get $this + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $10 + local.get $2 i32.store - local.get $10 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=4 - local.get $decoder - local.set $10 + local.get $2 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes + local.get $this + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/codec/Decoder#u24 - local.set $roLength - local.get $decoder - local.set $10 + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:source + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $10 + local.get $2 i32.store - local.get $10 - call $assembly/codec/Decoder#u24 - local.set $rwLength - local.get $decoder - local.set $10 + local.get $2 + local.get $this + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/codec/Decoder#u16 - local.set $_heapPages - local.get $decoder - local.set $10 + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $this + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $10 + local.get $2 i32.store - local.get $10 - call $assembly/codec/Decoder#u24 - local.set $_stackSize + local.get $2 + local.get $this + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $10 + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#get:offset + i32.const 1 + i32.add + call $assembly/codec/Decoder#set:offset + local.get $v + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $roLength - call $assembly/codec/Decoder#bytes - local.tee $_roMem - i32.store offset=8 + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $10 + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $10 + i32.const 0 i32.store - local.get $10 - local.get $rwLength - call $assembly/codec/Decoder#bytes - local.tee $_rwMem - i32.store offset=12 - local.get $decoder - local.set $10 + local.get $index + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $10 + local.get $3 i32.store - local.get $10 - call $assembly/codec/Decoder#u32 - local.set $codeLength - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $codeLength - call $assembly/codec/Decoder#bytes - local.tee $code - i32.store offset=16 - local.get $decoder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/codec/Decoder#finish - local.get $code - local.set $10 + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $10 + local.get $3 i32.store - local.get $10 - call $assembly/program/deblob - local.set $10 + local.get $3 + local.get $index + local.get $value + call $~lib/staticarray/StaticArray#__uset global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $10 - return ) - (func $assembly/index/disassemble (param $input i32) (param $kind i32) (param $withMetadata i32) (result i32) - (local $program i32) - (local $output i32) - (local $data i32) - (local $p i32) - (local $p|7 i32) - (local $8 i32) + (func $assembly/program/Mask#constructor (param $this i32) (param $packedMask i32) (param $codeLength i32) (result i32) + (local $lastInstructionOffset i32) + (local $i i32) + (local $bits i32) + (local $index i32) + (local $b i32) + (local $isSet i32) + (local $9 i32) global.get $~lib/memory/__stack_pointer - i32.const 44 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $input - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/program/liftBytes - local.tee $program - i32.store offset=4 + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - i32.const 14400 - local.tee $output + i32.const 0 i32.store offset=8 - local.get $withMetadata - global.get $assembly/index/HasMetadata.Yes - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $program - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/program/extractCodeAndMetadata - local.tee $data - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/program/CodeAndMetadata#get:code - local.tee $program - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 16656 - local.tee $output - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $output - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 16704 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String.__concat - local.tee $output - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $output - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=32 - local.get $8 - call $assembly/program/CodeAndMetadata#get:metadata - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=20 - local.get $8 - i32.const 16736 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 14400 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/typedarray/Uint8Array#reduce<~lib/string/String> - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String.__concat - local.tee $output - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $output - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 16768 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String.__concat - local.tee $output - i32.store offset=8 - end - local.get $kind - global.get $assembly/index/InputKind.Generic - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $program - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/program/deblob - local.tee $p - i32.store offset=36 - local.get $output - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $p - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=20 - local.get $8 - call $assembly/api-generic/getAssembly - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String.__concat - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $kind - global.get $assembly/index/InputKind.SPI - i32.eq + local.get $this + i32.eqz if global.get $~lib/memory/__stack_pointer - local.get $program - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/program/decodeSpi - local.tee $p|7 - i32.store offset=40 - local.get $output - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 + i32.const 4 + i32.const 31 + call $~lib/rt/itcms/__new + local.tee $this i32.store - local.get $8 - local.get $p|7 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=20 - local.get $8 - call $assembly/api-generic/getAssembly - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String.__concat - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return end - i32.const 17584 - local.set $8 + local.get $this + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString - local.set $8 + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + call $assembly/program/Mask#set:bytesToSkip + local.get $this + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/string/String#concat - local.set $8 + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + local.get $codeLength + call $~lib/staticarray/StaticArray#constructor + local.set $9 global.get $~lib/memory/__stack_pointer - i32.const 44 + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/Mask#set:bytesToSkip + i32.const 0 + local.set $lastInstructionOffset + local.get $packedMask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.const 1 + i32.sub + local.set $i + loop $for-loop|0 + local.get $i + i32.const 0 + i32.ge_s + if + local.get $packedMask + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + call $~lib/typedarray/Uint8Array#__get + local.set $bits + local.get $i + i32.const 8 + i32.mul + local.set $index + i32.const 7 + local.set $b + loop $for-loop|2 + local.get $b + i32.const 0 + i32.ge_s + if + local.get $bits + i32.const 128 + i32.and + local.set $isSet + local.get $bits + i32.const 1 + i32.const 7 + i32.and + i32.shl + local.set $bits + local.get $index + local.get $b + i32.add + local.get $codeLength + i32.lt_s + if + local.get $isSet + if (result i32) + i32.const 0 + else + local.get $lastInstructionOffset + i32.const 1 + i32.add + end + local.set $lastInstructionOffset + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/Mask#get:bytesToSkip + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $index + local.get $b + i32.add + local.get $lastInstructionOffset + global.get $assembly/program/MAX_SKIP + i32.const 1 + i32.add + i32.lt_u + if (result i32) + local.get $lastInstructionOffset + else + global.get $assembly/program/MAX_SKIP + i32.const 1 + i32.add + end + call $~lib/staticarray/StaticArray#__set + end + local.get $b + i32.const 1 + i32.sub + local.set $b + br $for-loop|2 + end + end + local.get $i + i32.const 1 + i32.sub + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $8 - return + local.get $9 ) - (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $bufferSize i32) - (local $buffer i32) - (local $6 i32) + (func $assembly/program/JumpTable#constructor (param $this i32) (param $itemBytes i32) (param $data i32) (result i32) + (local $jumps i32) + (local $i i32) + (local $num i64) + (local $j i32) + (local $nextNum i64) + (local $isOverflow i32) + (local $9 i32) global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub @@ -31313,125 +31653,161 @@ i32.eqz if global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 43 + i32.const 4 + i32.const 33 call $~lib/rt/itcms/__new local.tee $this i32.store end local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $9 i32.store offset=4 - local.get $6 + local.get $9 i32.const 0 - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 + call $assembly/program/JumpTable#set:jumps global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 i32.const 0 - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 + local.get $itemBytes + i32.const 255 + i32.and i32.const 0 - call $~lib/array/Array#set:length_ - local.get $length - i32.const 1073741820 - i32.const 3 - i32.shr_u i32.gt_u - if - i32.const 8176 - i32.const 8128 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable + if (result i32) + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + local.get $itemBytes + i32.const 255 + i32.and + i32.div_s + else + i32.const 0 end - local.get $length - local.tee $2 - i32.const 8 - local.tee $3 - local.get $2 - local.get $3 - i32.gt_u - select - i32.const 3 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer + call $~lib/staticarray/StaticArray#constructor + local.tee $jumps i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $bufferSize - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + i64.const 0 + local.set $num + local.get $itemBytes + i32.const 1 + i32.sub + i32.const 255 + i32.and + local.set $j + loop $for-loop|1 + local.get $j + i32.const 0 + i32.ge_s + if + local.get $num + i64.const 8 + i64.shl + local.set $nextNum + local.get $nextNum + local.get $num + i64.lt_u + local.set $isOverflow + local.get $nextNum + local.get $data + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + local.get $j + i32.add + call $~lib/typedarray/Uint8Array#__get + i64.extend_i32_u + i64.add + local.set $nextNum + local.get $isOverflow + if (result i32) + i32.const 1 + else + local.get $nextNum + local.get $num + i64.lt_u + end + local.set $isOverflow + local.get $isOverflow + if (result i64) + global.get $~lib/builtins/u64.MAX_VALUE + else + local.get $nextNum + end + local.set $num + local.get $j + i32.const 1 + i32.sub + local.set $j + br $for-loop|1 + end + end + local.get $jumps + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $i + local.get $itemBytes + i32.const 255 + i32.and + i32.div_s + local.get $num + call $~lib/staticarray/StaticArray#__set + local.get $i + local.get $itemBytes + i32.const 255 + i32.and + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $9 i32.store offset=4 - local.get $6 - local.get $length - call $~lib/array/Array#set:length_ + local.get $9 + local.get $jumps + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $assembly/program/JumpTable#set:jumps local.get $this - local.set $6 + local.set $9 global.get $~lib/memory/__stack_pointer i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $6 + local.get $9 ) - (func $~lib/array/Array#fill (param $this i32) (param $value i64) (param $start i32) (param $end i32) (result i32) - (local $4 i32) + (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub @@ -31440,37 +31816,40 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store - i32.const 0 - drop + local.get $index local.get $this - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store - local.get $4 - call $~lib/array/Array#get:dataStart + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end local.get $this - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store - local.get $4 - call $~lib/array/Array#get:length_ + local.get $3 + local.get $index local.get $value - local.get $start - local.get $end - call $~lib/util/bytes/FILL - local.get $this - local.set $4 + call $~lib/staticarray/StaticArray#__uset global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 - return ) - (func $~lib/array/Array#fill@varargs (param $this i32) (param $value i64) (param $start i32) (param $end i32) (result i32) - (local $4 i32) + (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub @@ -31479,45 +31858,51 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end + local.get $index local.get $this - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 i32.store - local.get $4 + local.get $3 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + i32.const 480 + i32.const 8288 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.set $value + i32.const 0 + drop local.get $value - local.get $start - local.get $end - call $~lib/array/Array#fill - local.set $4 + local.set $3 global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $3 + return ) - (func $assembly/api-generic/VmInput#constructor (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) + (func $assembly/program/BasicBlocks#constructor (param $this i32) (param $code i32) (param $mask i32) (result i32) + (local $len i32) + (local $isStartOrEnd i32) + (local $n i32) + (local $isInstructionInMask i32) + (local $skipArgs i32) + (local $iData i32) + (local $isTerminating i32) + (local $newBlockStart i32) + (local $11 i32) global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub @@ -31533,174 +31918,445 @@ i32.eqz if global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 47 + i32.const 4 + i32.const 34 call $~lib/rt/itcms/__new local.tee $this i32.store end - global.get $~lib/memory/__stack_pointer local.get $this - local.set $4 + local.set $11 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $11 i32.store offset=4 - local.get $4 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $4 + local.get $11 + i32.const 0 + call $assembly/program/BasicBlocks#set:isStartOrEnd + local.get $code + local.set $11 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $11 i32.store offset=4 - local.get $4 - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/array/Array#constructor - local.set $4 + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + local.set $len global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i64.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength i32.const 0 - call $~lib/array/Array#fill@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $len + call $~lib/staticarray/StaticArray#constructor + local.tee $isStartOrEnd i32.store offset=8 - local.get $4 - call $assembly/api-generic/VmInput#set:registers + local.get $len + i32.const 0 + i32.gt_s + if + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + end + i32.const 0 + local.set $n + loop $for-loop|0 + local.get $n + local.get $len + i32.lt_s + if + block $for-continue|0 + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $assembly/program/Mask#isInstruction + local.set $isInstructionInMask + local.get $isInstructionInMask + i32.eqz + if + br $for-continue|0 + end + local.get $mask + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipArgs + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $code + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#__get + end + local.set $iData + local.get $iData + call $assembly/instructions/Instruction#get:isTerminating + local.set $isTerminating + local.get $isTerminating + if + local.get $n + i32.const 1 + i32.add + local.get $skipArgs + i32.add + local.set $newBlockStart + local.get $newBlockStart + local.get $len + i32.lt_s + if + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $newBlockStart + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + end + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + local.get $n + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.END + i32.or + call $~lib/staticarray/StaticArray#__set + end + end + local.get $n + i32.const 1 + i32.add + local.set $n + br $for-loop|0 + end + end local.get $this - local.set $4 + local.set $11 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $11 i32.store offset=4 - local.get $4 + local.get $11 + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=12 + local.get $11 + call $assembly/program/BasicBlocks#set:isStartOrEnd + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + ) + (func $assembly/program/Program#constructor (param $this i32) (param $code i32) (param $mask i32) (param $jumpTable i32) (param $basicBlocks i32) (result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer i32.const 0 - call $assembly/api-generic/VmInput#set:pc + i32.store offset=8 local.get $this - local.set $4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 30 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store offset=4 - local.get $4 - i64.const 0 - call $assembly/api-generic/VmInput#set:gas + local.get $5 + local.get $code + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/Program#set:code local.get $this - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store offset=4 - local.get $4 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 17632 - call $~lib/rt/__newArray - local.set $4 + local.get $5 + local.get $mask + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store offset=8 - local.get $4 - call $assembly/api-generic/VmInput#set:program + local.get $5 + call $assembly/program/Program#set:mask local.get $this - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store offset=4 - local.get $4 - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 17664 - call $~lib/rt/__newArray - local.set $4 + local.get $5 + local.get $jumpTable + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store offset=8 - local.get $4 - call $assembly/api-generic/VmInput#set:pageMap + local.get $5 + call $assembly/program/Program#set:jumpTable local.get $this - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store offset=4 - local.get $4 - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 17696 - call $~lib/rt/__newArray - local.set $4 + local.get $5 + local.get $basicBlocks + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $5 i32.store offset=8 - local.get $4 - call $assembly/api-generic/VmInput#set:memory + local.get $5 + call $assembly/program/Program#set:basicBlocks local.get $this - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $5 ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i64) - (local $value i64) - (local $3 i32) - (local $4 i64) + (func $assembly/program/deblob (param $program i32) (result i32) + (local $decoder i32) + (local $jumpTableLength i32) + (local $jumpTableItemLength i32) + (local $codeLength i32) + (local $jumpTableLengthInBytes i32) + (local $rawJumpTable i32) + (local $rawCode i32) + (local $rawMask i32) + (local $mask i32) + (local $jumpTable i32) + (local $basicBlocks i32) + (local $12 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 44 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $program + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 i32.store - local.get $index - local.get $this - local.set $3 + local.get $12 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=4 + local.get $decoder + local.set $12 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $12 i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 + local.get $12 + call $assembly/codec/Decoder#varU32 + local.set $jumpTableLength + local.get $decoder + local.set $12 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $12 i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 3 - i32.shl + local.get $12 + call $assembly/codec/Decoder#u8 + local.set $jumpTableItemLength + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/codec/Decoder#varU32 + local.set $codeLength + local.get $jumpTableLength + local.get $jumpTableItemLength + i32.mul + local.set $jumpTableLengthInBytes + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $jumpTableLengthInBytes + call $assembly/codec/Decoder#bytes + local.tee $rawJumpTable + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + call $assembly/codec/Decoder#bytes + local.tee $rawCode + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $codeLength + i32.const 7 i32.add - i64.load - local.set $value + i32.const 8 + i32.div_u + call $assembly/codec/Decoder#bytes + local.tee $rawMask + i32.store offset=16 + global.get $~lib/memory/__stack_pointer i32.const 0 - drop - local.get $value - local.set $4 + local.get $rawMask + local.set $12 global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $12 + i32.store + local.get $12 + local.get $codeLength + call $assembly/program/Mask#constructor + local.tee $mask + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $jumpTableItemLength + local.get $rawJumpTable + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/program/JumpTable#constructor + local.tee $jumpTable + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $rawCode + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $mask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=28 + local.get $12 + call $assembly/program/BasicBlocks#constructor + local.tee $basicBlocks + i32.store offset=32 + i32.const 0 + local.get $rawCode + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + local.get $mask + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=28 + local.get $12 + local.get $jumpTable + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=36 + local.get $12 + local.get $basicBlocks + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=40 + local.get $12 + call $assembly/program/Program#constructor + local.set $12 + global.get $~lib/memory/__stack_pointer + i32.const 44 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $12 return ) (func $"~lib/map/Map#constructor" (param $this i32) (result i32) @@ -32076,7 +32732,7 @@ i32.const 0 i32.const 2 i32.const 17 - i32.const 17728 + i32.const 18032 call $~lib/rt/__newArray local.set $5 global.get $~lib/memory/__stack_pointer @@ -32182,7 +32838,7 @@ if global.get $~lib/memory/__stack_pointer i32.const 8 - i32.const 50 + i32.const 45 call $~lib/rt/itcms/__new local.tee $this i32.store @@ -32234,96 +32890,132 @@ global.set $~lib/memory/__stack_pointer local.get $1 ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) + (func $assembly/memory/MemoryBuilder#getOrCreatePageForAddress (param $this i32) (param $access i32) (param $address i32) (result i32) + (local $pageIdx i32) + (local $page i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $index - local.get $this - local.set $3 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u + i64.const 0 + i64.store offset=8 + local.get $address + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i32.shr_u + local.set $pageIdx + local.get $pageIdx + global.get $assembly/memory-page/RESERVED_PAGES + i32.lt_u if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 + i32.const 18064 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + i32.const 10 + call $~lib/number/U32#toString + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/string/String#concat + i32.const 18160 + i32.const 93 + i32.const 7 call $~lib/builtins/abort unreachable end - global.get $~lib/memory/__stack_pointer local.get $this - local.set $3 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value + local.get $5 i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value + local.get $5 + call $assembly/memory/MemoryBuilder#get:pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + call $"~lib/map/Map#has" i32.eqz if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/MemoryBuilder#get:arena + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=8 + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory/MemoryBuilder#get:pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + i32.const 0 + local.get $access + local.get $page + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $assembly/memory-page/Page#constructor + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + call $"~lib/map/Map#set" + drop end - local.get $value - local.set $3 + local.get $this + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $5 + i32.store offset=4 + local.get $5 + call $assembly/memory/MemoryBuilder#get:pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $pageIdx + call $"~lib/map/Map#get" + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $5 return ) (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $this i32) (param $source i32) (param $offset i32) @@ -32428,21 +33120,19 @@ (func $assembly/memory/MemoryBuilder#setData (param $this i32) (param $access i32) (param $address i32) (param $data i32) (result i32) (local $currentAddress i32) (local $currentData i32) - (local $pageIdx i32) (local $page i32) (local $relAddress i32) - (local $page|9 i32) (local $spaceInPage i32) (local $end i32) - (local $12 i32) + (local $10 i32) global.get $~lib/memory/__stack_pointer - i32.const 28 + i32.const 24 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 28 + i32.const 24 memory.fill local.get $address local.set $currentAddress @@ -32452,184 +33142,88 @@ i32.store loop $while-continue|0 local.get $currentData - local.set $12 + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $10 i32.store offset=4 - local.get $12 + local.get $10 call $~lib/typedarray/Uint8Array#get:length i32.const 0 i32.gt_s if - local.get $currentAddress - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $pageIdx - local.get $pageIdx - global.get $assembly/memory-page/RESERVED_PAGES - i32.lt_u - if - i32.const 17760 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $pageIdx - i32.const 10 - call $~lib/number/U32#toString - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/string/String#concat - i32.const 17856 - i32.const 67 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $12 global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $assembly/memory/MemoryBuilder#get:pages - local.set $12 + local.get $this + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $10 i32.store offset=4 - local.get $12 - local.get $pageIdx - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $assembly/memory/MemoryBuilder#get:arena - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=12 - local.get $this - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=16 - local.get $12 - call $assembly/memory/MemoryBuilder#get:pages - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $pageIdx - i32.const 0 - local.get $access - local.get $page - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=16 - local.get $12 - call $assembly/memory-page/Page#constructor - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $"~lib/map/Map#set" - drop - end + local.get $10 + local.get $access + local.get $currentAddress + call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress + local.tee $page + i32.store offset=8 local.get $currentAddress global.get $assembly/memory-page/PAGE_SIZE i32.rem_u local.set $relAddress - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $assembly/memory/MemoryBuilder#get:pages - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $pageIdx - call $"~lib/map/Map#get" - local.tee $page|9 - i32.store offset=20 global.get $assembly/memory-page/PAGE_SIZE local.get $relAddress i32.sub local.set $spaceInPage local.get $currentData - local.set $12 + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $10 i32.store offset=4 - local.get $12 + local.get $10 call $~lib/typedarray/Uint8Array#get:length local.get $spaceInPage i32.lt_u if (result i32) local.get $currentData - local.set $12 + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $10 i32.store offset=4 - local.get $12 + local.get $10 call $~lib/typedarray/Uint8Array#get:length else local.get $spaceInPage end local.set $end - local.get $page|9 - local.set $12 + local.get $page + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=24 - local.get $12 + local.get $10 + i32.store offset=20 + local.get $10 call $assembly/memory-page/Page#get:raw - local.set $12 + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $10 i32.store offset=16 - local.get $12 + local.get $10 call $assembly/memory-page/RawPage#get:data - local.set $12 + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $10 i32.store offset=4 - local.get $12 + local.get $10 local.get $currentData - local.set $12 + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $10 i32.store offset=16 - local.get $12 + local.get $10 i32.const 0 local.get $end call $~lib/typedarray/Uint8Array#subarray - local.set $12 + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 + local.get $10 + i32.store offset=12 + local.get $10 local.get $relAddress call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> local.get $currentAddress @@ -32638,11 +33232,11 @@ local.set $currentAddress global.get $~lib/memory/__stack_pointer local.get $currentData - local.set $12 + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $12 + local.get $10 i32.store offset=4 - local.get $12 + local.get $10 local.get $end i32.const 1 global.set $~argumentsLength @@ -32654,16 +33248,18 @@ end end local.get $this - local.set $12 + local.set $10 global.get $~lib/memory/__stack_pointer - i32.const 28 + i32.const 24 i32.add global.set $~lib/memory/__stack_pointer - local.get $12 + local.get $10 return ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) + (func $assembly/memory/MemoryBuilder#setEmpty (param $this i32) (param $access i32) (param $address i32) (param $len i32) (result i32) + (local $endAddress i32) + (local $currentAddress i32) + (local $6 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub @@ -32672,86 +33268,41 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $address + local.get $len i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable + local.set $endAddress + local.get $address + local.set $currentAddress + loop $for-loop|0 + local.get $currentAddress + local.get $endAddress + i32.lt_u + if + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $access + local.get $currentAddress + call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress + drop + local.get $currentAddress + global.get $assembly/memory-page/PAGE_SIZE + i32.add + local.set $currentAddress + br $for-loop|0 + end end - global.get $~lib/memory/__stack_pointer local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 + local.set $6 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $6 return ) (func $assembly/memory/Memory#constructor (param $this i32) (param $arena i32) (param $pages i32) (param $sbrkAddress i32) (result i32) @@ -32828,9 +33379,9 @@ global.get $assembly/memory-page/RESERVED_PAGES i32.lt_u if - i32.const 17920 - i32.const 17856 - i32.const 104 + i32.const 18224 + i32.const 18160 + i32.const 119 i32.const 7 call $~lib/builtins/abort unreachable @@ -32913,291 +33464,7 @@ local.get $2 return ) - (func $assembly/api-generic/buildMemory (param $builder i32) (param $pages i32) (param $chunks i32) (result i32) - (local $sbrkIndex i32) - (local $i i32) - (local $initPage i32) - (local $i|6 i32) - (local $initChunk i32) - (local $data i32) - (local $i|9 i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $assembly/memory-page/RESERVED_MEMORY - local.set $sbrkIndex - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pages - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/array/Array#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $pages - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $i - call $~lib/array/Array#__get - local.tee $initPage - i32.store offset=4 - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-generic/InitialPage#get:access - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-generic/InitialPage#get:address - i32.const 0 - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-generic/InitialPage#get:length - call $~lib/typedarray/Uint8Array#constructor - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/MemoryBuilder#setData - drop - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/api-generic/InitialPage#get:access - global.get $assembly/memory-page/Access.Write - i32.eq - if - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/api-generic/InitialPage#get:address - local.get $sbrkIndex - i32.lt_u - if (result i32) - local.get $sbrkIndex - else - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/api-generic/InitialPage#get:address - end - local.set $sbrkIndex - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|6 - loop $for-loop|1 - local.get $i|6 - local.get $chunks - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/array/Array#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $chunks - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $i|6 - call $~lib/array/Array#__get - local.tee $initChunk - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $initChunk - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/api-generic/InitialChunk#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $data - i32.store offset=20 - i32.const 0 - local.set $i|9 - loop $for-loop|2 - local.get $i|9 - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $i|9 - local.get $initChunk - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-generic/InitialChunk#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - local.get $i|9 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $i|9 - i32.const 1 - i32.add - local.set $i|9 - br $for-loop|2 - end - end - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - global.get $assembly/memory-page/Access.None - local.get $initChunk - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-generic/InitialChunk#get:address - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/MemoryBuilder#setData - drop - local.get $i|6 - i32.const 1 - i32.add - local.set $i|6 - br $for-loop|1 - end - end - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $sbrkIndex - call $assembly/memory/MemoryBuilder#build - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $assembly/gas/GasCounterU64#constructor (param $this i32) (param $gas i64) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 51 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $gas - call $assembly/gas/GasCounterU64#set:gas - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/interpreter/Interpreter#constructor (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) + (func $assembly/spi/StandardProgram#constructor (param $this i32) (param $program i32) (param $memory i32) (param $registers i32) (result i32) (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 12 @@ -33214,8 +33481,8 @@ i32.eqz if global.get $~lib/memory/__stack_pointer - i32.const 33 - i32.const 29 + i32.const 28 + i32.const 44 call $~lib/rt/itcms/__new local.tee $this i32.store @@ -33226,9 +33493,565 @@ local.get $4 i32.store offset=4 local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:program - local.get $this + local.get $program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:program + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:memory + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:registers + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/spi/StandardProgram#set:metadata + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/spi/StandardProgram#set:pc + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i64.const 0 + call $assembly/spi/StandardProgram#set:gas + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/spi/decodeSpi (param $data i32) (param $args i32) (result i32) + (local $argsLength i32) + (local $3 i32) + (local $4 i32) + (local $decoder i32) + (local $roLength i32) + (local $rwLength i32) + (local $heapPages i32) + (local $stackSize i32) + (local $roMem i32) + (local $rwMem i32) + (local $codeLength i32) + (local $code i32) + (local $program i32) + (local $builder i32) + (local $heapStart i32) + (local $heapZerosStart i32) + (local $heapZerosLength i32) + (local $heapZerosEnd i32) + (local $stackLength i32) + (local $stackStart i32) + (local $memory i32) + (local $registers i32) + (local $24 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill + local.get $args + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + call $~lib/typedarray/Uint8Array#get:length + local.set $argsLength + local.get $argsLength + global.get $assembly/spi/MAX_ARGS_LEN + i32.gt_u + if + global.get $~lib/memory/__stack_pointer + local.get $argsLength + i32.const 10 + call $~lib/number/U32#toString + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + global.get $assembly/spi/MAX_ARGS_LEN + i32.const 10 + call $~lib/number/U32#toString + local.tee $4 + i32.store offset=8 + i32.const 17792 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 1 + local.get $3 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=12 + local.get $24 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 17792 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 3 + local.get $4 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=12 + local.get $24 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 17792 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 14480 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=12 + local.get $24 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 17840 + i32.const 18 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $data + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $decoder + i32.store offset=16 + local.get $decoder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + call $assembly/codec/Decoder#u24 + local.set $roLength + local.get $decoder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + call $assembly/codec/Decoder#u24 + local.set $rwLength + local.get $decoder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + call $assembly/codec/Decoder#u16 + local.set $heapPages + local.get $decoder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + call $assembly/codec/Decoder#u24 + local.set $stackSize + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + local.get $roLength + call $assembly/codec/Decoder#bytes + local.tee $roMem + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + local.get $rwLength + call $assembly/codec/Decoder#bytes + local.tee $rwMem + i32.store offset=24 + local.get $decoder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + call $assembly/codec/Decoder#u32 + local.set $codeLength + global.get $~lib/memory/__stack_pointer + local.get $decoder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + local.get $codeLength + call $assembly/codec/Decoder#bytes + local.tee $code + i32.store offset=28 + local.get $decoder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + call $assembly/codec/Decoder#finish + global.get $~lib/memory/__stack_pointer + local.get $code + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + call $assembly/program/deblob + local.tee $program + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store offset=36 + i32.const 2 + global.get $assembly/memory-page/SEGMENT_SIZE + i32.mul + local.get $roLength + call $assembly/spi/alignToSegmentSize + i32.add + local.set $heapStart + local.get $heapStart + local.get $rwLength + call $assembly/spi/alignToPageSize + i32.add + local.set $heapZerosStart + local.get $heapPages + i32.const 65535 + i32.and + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.set $heapZerosLength + local.get $heapZerosStart + local.get $heapZerosLength + i32.add + local.set $heapZerosEnd + local.get $stackSize + call $assembly/spi/alignToPageSize + local.set $stackLength + global.get $assembly/spi/STACK_SEGMENT_END + local.get $stackLength + i32.sub + local.set $stackStart + local.get $roLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + global.get $assembly/memory-page/Access.Read + global.get $assembly/memory-page/SEGMENT_SIZE + local.get $roMem + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=12 + local.get $24 + call $assembly/memory/MemoryBuilder#setData + drop + end + local.get $argsLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + global.get $assembly/memory-page/Access.Read + global.get $assembly/spi/ARGS_SEGMENT_START + local.get $args + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=12 + local.get $24 + call $assembly/memory/MemoryBuilder#setData + drop + end + local.get $rwLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + global.get $assembly/memory-page/Access.Write + local.get $heapStart + local.get $rwMem + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=12 + local.get $24 + call $assembly/memory/MemoryBuilder#setData + drop + end + local.get $heapZerosLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + global.get $assembly/memory-page/Access.Write + local.get $heapZerosStart + local.get $heapZerosLength + call $assembly/memory/MemoryBuilder#setEmpty + drop + end + local.get $stackLength + i32.const 0 + i32.gt_u + if + local.get $builder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + global.get $assembly/memory-page/Access.Write + local.get $stackStart + local.get $stackLength + call $assembly/memory/MemoryBuilder#setEmpty + drop + end + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + local.get $heapZerosEnd + call $assembly/memory/MemoryBuilder#build + local.tee $memory + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=44 + local.get $registers + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 0 + i64.const 4294901760 + call $~lib/staticarray/StaticArray#__set + local.get $registers + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 1 + global.get $assembly/spi/STACK_SEGMENT_END + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + local.get $registers + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 7 + global.get $assembly/spi/ARGS_SEGMENT_START + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + local.get $registers + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 8 + local.get $argsLength + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + i32.const 0 + local.get $program + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + local.get $memory + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=12 + local.get $24 + local.get $registers + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=48 + local.get $24 + call $assembly/spi/StandardProgram#constructor + local.set $24 + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $24 + return + ) + (func $assembly/gas/GasCounterU64#constructor (param $this i32) (param $gas i64) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 46 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $gas + call $assembly/gas/GasCounterU64#set:gas + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/interpreter/Interpreter#constructor (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 33 + i32.const 29 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + call $assembly/interpreter/Interpreter#set:program + local.get $this local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 @@ -33393,279 +34216,331 @@ global.set $~lib/memory/__stack_pointer local.get $4 ) - (func $~lib/string/String#substring (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $len i32) - (local $4 i32) - (local $5 i32) + (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $bufferSize i32) + (local $buffer i32) (local $6 i32) - (local $7 i32) - (local $finalStart i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $finalEnd i32) - (local $14 i32) - (local $15 i32) - (local $fromPos i32) - (local $17 i32) - (local $18 i32) - (local $toPos i32) - (local $size i32) - (local $out i32) - (local $22 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $this - local.set $22 global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $~lib/string/String#get:length - local.set $len - local.get $start - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - local.tee $6 - local.get $len - local.tee $7 - local.get $6 - local.get $7 - i32.lt_s - select - local.set $finalStart - local.get $end - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_s - select - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - local.set $finalEnd - local.get $finalStart - local.tee $14 - local.get $finalEnd - local.tee $15 - local.get $14 - local.get $15 - i32.lt_s - select - i32.const 1 - i32.shl - local.set $fromPos - local.get $finalStart - local.tee $17 - local.get $finalEnd - local.tee $18 - local.get $17 - local.get $18 - i32.gt_s - select - i32.const 1 - i32.shl - local.set $toPos - local.get $toPos - local.get $fromPos - i32.sub - local.set $size - local.get $size - i32.eqz - if - i32.const 14400 - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - end - local.get $fromPos + i64.const 0 + i64.store offset=8 + local.get $this i32.eqz - if (result i32) - local.get $toPos - local.get $len - i32.const 1 - i32.shl - i32.eq - else - i32.const 0 - end if - local.get $this - local.set $22 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return + i32.const 16 + i32.const 47 + call $~lib/rt/itcms/__new + local.tee $this + i32.store end + local.get $this + local.set $6 global.get $~lib/memory/__stack_pointer - local.get $size - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out + local.get $6 i32.store offset=4 - local.get $out + local.get $6 + i32.const 0 + call $~lib/array/Array#set:buffer local.get $this - local.get $fromPos - i32.add - local.get $size - memory.copy - local.get $out - local.set $22 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:length_ + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8128 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + local.tee $2 i32.const 8 + local.tee $3 + local.get $2 + local.get $3 + i32.gt_u + select + i32.const 2 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $bufferSize + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $length + call $~lib/array/Array#set:length_ + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $22 - return + local.get $6 ) - (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $value i64) - (local $sepLen i32) - (local $estLen i32) - (local $result i32) - (local $offset i32) - (local $value|9 i64) - (local $i i32) - (local $11 i32) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex i32.const 0 - i32.lt_s - if - i32.const 14400 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $lastIndex - i32.eqz + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u if - local.get $dataStart - i64.load - local.set $value + local.get $index i32.const 0 - drop - i32.const 8 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 10 - call $~lib/util/number/utoa64 - local.set $11 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return + call $~lib/array/Array#set:length_ end - local.get $separator - local.set $11 + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $11 + local.get $3 i32.store - local.get $11 - call $~lib/string/String#get:length - local.set $sepLen - i32.const 20 - local.get $sepLen + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl i32.add - local.get $lastIndex - i32.mul - i32.const 20 + local.get $value + i32.store + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 4 i32.add - local.set $estLen + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - local.get $estLen - i32.const 1 - i32.shl + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.get $newLength i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result + i32.const 0 + call $~lib/array/ensureCapacity + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $newLength + call $~lib/array/Array#set:length_ + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#values" (param $this i32) (result i32) + (local $start i32) + (local $size i32) + (local $values i32) + (local $length i32) + (local $i i32) + (local $entry i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.set $start + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.set $size + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $size + call $~lib/array/Array#constructor + local.tee $values i32.store offset=4 i32.const 0 - local.set $offset + local.set $length i32.const 0 local.set $i loop $for-loop|0 local.get $i - local.get $lastIndex + local.get $size i32.lt_s if - local.get $dataStart + local.get $start local.get $i - i32.const 3 - i32.shl + block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.6" + end + i32.mul i32.add - i64.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $sepLen + i32.and + i32.eqz if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + local.tee $7 i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen i32.add - local.set $offset + local.set $length + local.get $7 + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/array/Array#__set end local.get $i i32.const 1 @@ -33674,91 +34549,50 @@ br $for-loop|0 end end - local.get $dataStart - local.get $lastIndex - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $estLen - local.get $offset - i32.gt_s - if - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.const 0 - local.get $offset - call $~lib/string/String#substring - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $result - local.set $11 + local.get $values + local.set $8 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $8 + i32.store + local.get $8 + local.get $length + call $~lib/array/Array#set:length + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $11 + local.get $8 return ) - (func $~lib/staticarray/StaticArray#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store i32.const 0 - drop - i32.const 1 - drop - local.get $this + i32.store local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/staticarray/StaticArray#get:length - local.get $separator - local.set $2 + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $1 i32.store - local.get $2 - call $~lib/util/string/joinIntegerArray - local.set $2 + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $1 return ) - (func $assembly/api-generic/runVm~anonymous|0 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 8 @@ -33768,176 +34602,119 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - i32.const 16704 + local.get $index + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 i32.store local.get $3 - local.get $x - i32.const 16 - call $~lib/number/U64#toString + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 + i32.store local.get $3 - call $~lib/string/String#concat + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 14704 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value local.set $3 global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer local.get $3 + return ) - (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $this i32) (param $fn i32) (result i32) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) (local $len i32) - (local $out i32) - (local $outStart i32) - (local $i i32) - (local $result i32) - (local $7 i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 + i32.store local.get $this - local.set $7 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $7 + local.get $4 i32.store - local.get $7 - call $~lib/staticarray/StaticArray#get:length + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add local.set $len - global.get $~lib/memory/__stack_pointer + local.get $this local.get $len i32.const 2 - i32.const 52 - i32.const 0 - call $~lib/rt/__newArray - local.tee $out - i32.store offset=4 - local.get $out - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.set $outStart - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.get $i - i32.const 3 - i32.shl - i32.add - i64.load - local.get $i - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - i32.const 3 - global.set $~argumentsLength - local.get $fn - i32.load - call_indirect (type $17) - local.tee $result - i32.store offset=8 - local.get $outStart - local.get $i - i32.const 2 - i32.shl - i32.add - local.get $result - i32.store - i32.const 1 - drop - local.get $out - local.get $result - i32.const 1 - call $~lib/rt/itcms/__link - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $out - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $~lib/array/Array<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) - (local $ptr i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 1 + drop local.get $this local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.set $ptr - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value i32.store - local.get $4 - call $~lib/array/Array<~lib/string/String>#get:length_ - local.set $len - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - i32.const 1 - i32.lt_s - drop + local.get $this + local.get $value i32.const 1 - drop - local.get $ptr - local.get $len - local.get $separator + call $~lib/rt/itcms/__link + local.get $this local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - call $~lib/util/string/joinStringArray + local.get $len + call $~lib/array/Array#set:length_ + local.get $len local.set $4 global.get $~lib/memory/__stack_pointer i32.const 4 @@ -33946,130 +34723,134 @@ local.get $4 return ) - (func $assembly/api-generic/runVm~anonymous|1 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) + (func $assembly/memory-page/Arena#release (param $this i32) (param $page i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - i32.const 16704 - local.set $3 global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 0 + i32.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory-page/Arena#get:free + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 i32.store - local.get $3 - local.get $x - i32.const 16 - call $~lib/number/U64#toString - local.set $3 + local.get $2 + local.get $page + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $2 i32.store offset=4 - local.get $3 - call $~lib/string/String#concat - local.set $3 + local.get $2 + call $~lib/array/Array#push + drop global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 ) - (func $assembly/program/ResolvedArguments#constructor (param $this i32) (result i32) + (func $"~lib/map/Map#clear" (param $this i32) (local $1 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.const 54 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $this + local.get $1 + i32.store + local.get $1 + i32.const 0 + i32.const 4 + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store + call $"~lib/map/Map#set:buckets" local.get $this local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 + i32.store local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:a + i32.const 4 + i32.const 1 + i32.sub + call $"~lib/map/Map#set:bucketsMask" local.get $this local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 + i32.store local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:b - local.get $this + i32.const 0 + i32.const 4 + block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.7" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:c + call $"~lib/map/Map#set:entries" local.get $this local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 + i32.store local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:d + i32.const 4 + call $"~lib/map/Map#set:entriesCapacity" local.get $this local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 + i32.store local.get $1 i32.const 0 - call $assembly/arguments/Args#constructor + call $"~lib/map/Map#set:entriesOffset" + local.get $this local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=8 + i32.store local.get $1 - call $assembly/program/ResolvedArguments#set:decoded - local.get $this - local.set $1 + i32.const 0 + call $"~lib/map/Map#set:entriesCount" global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $1 ) - (func $assembly/program/resolveArguments (param $kind i32) (param $data i32) (param $lim i32) (param $registers i32) (result i32) - (local $args i32) - (local $resolved i32) - (local $6 i32) - (local $7 i32) + (func $assembly/memory/Memory#free (param $this i32) + (local $pages i32) + (local $i i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 20 i32.sub @@ -34080,2603 +34861,1877 @@ i32.const 20 memory.fill global.get $~lib/memory/__stack_pointer - local.get $kind - local.get $data - local.set $7 + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $7 + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory/Memory#get:pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store - local.get $7 - local.get $lim - call $assembly/program/decodeArguments - local.tee $args + local.get $3 + call $"~lib/map/Map#values" + local.tee $pages + i32.store offset=8 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + i32.lt_s + if + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/memory/Memory#get:arena + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + local.get $i + call $~lib/array/Array#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/memory-page/Page#get:raw + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/memory-page/Arena#release + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store offset=4 - local.get $args + local.get $3 + call $assembly/memory/Memory#get:pages + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $"~lib/map/Map#clear" + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-debugger/resetJAM (param $program i32) (param $pc f64) (param $initialGas i64) (param $args i32) (param $hasMetadata i32) + (local $code i32) + (local $p i32) + (local $int i32) + (local $8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer i32.const 0 - i32.eq - if - i32.const 0 - local.set $7 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $hasMetadata + if (result i32) + local.get $program + local.set $9 global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/liftBytes + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/program/extractCodeAndMetadata + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $assembly/program/CodeAndMetadata#get:code + else + local.get $program + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $assembly/program/liftBytes end + local.tee $code + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $code + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $args + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/liftBytes + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/spi/decodeSpi + local.tee $p + i32.store offset=16 global.get $~lib/memory/__stack_pointer i32.const 0 - call $assembly/program/ResolvedArguments#constructor - local.tee $resolved + local.get $p + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=20 + local.get $9 + call $assembly/spi/StandardProgram#get:program + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $p + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=20 + local.get $9 + call $assembly/spi/StandardProgram#get:registers + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $p + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=20 + local.get $9 + call $assembly/spi/StandardProgram#get:memory + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 i32.store offset=8 - local.get $resolved - local.set $7 + local.get $9 + call $assembly/interpreter/Interpreter#constructor + local.tee $int + i32.store offset=24 + local.get $int + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $7 + local.get $9 i32.store - local.get $7 - local.get $args - local.set $7 + local.get $9 + local.get $pc + i32.trunc_sat_f64_u + call $assembly/interpreter/Interpreter#set:nextPc + local.get $int + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/program/ResolvedArguments#set:decoded - block $case13|0 - block $case12|0 - block $case11|0 - block $case10|0 - block $case9|0 - block $case8|0 - block $case7|0 - block $case6|0 - block $case5|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $kind - local.set $6 - local.get $6 - global.get $assembly/arguments/Arguments.Zero - i32.eq - br_if $case0|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneImm - i32.eq - br_if $case1|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoImm - i32.eq - br_if $case2|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneOff - i32.eq - br_if $case3|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegOneImm - i32.eq - br_if $case4|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegOneExtImm - i32.eq - br_if $case5|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i32.eq - br_if $case6|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i32.eq - br_if $case7|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoReg - i32.eq - br_if $case8|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i32.eq - br_if $case9|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i32.eq - br_if $case10|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoRegTwoImm - i32.eq - br_if $case11|0 - local.get $6 - global.get $assembly/arguments/Arguments.ThreeReg - i32.eq - br_if $case12|0 - br $case13|0 - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - i64.const 32 - i64.shl - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - i64.add - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:d - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:d - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - i32.const 18528 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $~lib/string/String#concat - i32.const 18608 - i32.const 347 - i32.const 7 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/interpreter/Interpreter#get:gas + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $9 i32.store - local.get $3 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop + local.get $9 + local.get $initialGas + call $assembly/gas/GasCounter#set@override + global.get $assembly/api-debugger/interpreter i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/interpreter/DjumpResult#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz + i32.ne if global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 55 - call $~lib/rt/itcms/__new - local.tee $this + global.get $assembly/api-debugger/interpreter + local.tee $8 + i32.store offset=28 + local.get $8 + if (result i32) + local.get $8 + else + i32.const 9488 + i32.const 18336 + i32.const 22 + i32.const 19 + call $~lib/builtins/abort + unreachable + end + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/interpreter/Interpreter#get:memory + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 i32.store + local.get $9 + call $assembly/memory/Memory#free end + local.get $int + global.set $assembly/api-debugger/interpreter global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/interpreter/DjumpStatus.OK - call $assembly/interpreter/DjumpResult#set:status - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/interpreter/DjumpResult#set:newPc - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 32 i32.add global.set $~lib/memory/__stack_pointer - local.get $1 ) - (func $assembly/interpreter/dJump (param $jumpTable i32) (param $address i32) (result i32) - (local $r i32) - (local $index i32) - (local $newPc i64) + (func $assembly/api-debugger/resetJAM@varargs (param $program i32) (param $pc f64) (param $initialGas i64) (param $args i32) (param $hasMetadata i32) (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/interpreter/DjumpResult#constructor - local.tee $r - i32.store - local.get $address - global.get $assembly/interpreter/EXIT - i32.eq - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.HALT - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $address - i32.const 0 - i32.eq - if (result i32) - i32.const 1 - else - local.get $address - global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR - i32.rem_u + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 4 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end i32.const 0 - i32.ne - end - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.PANIC - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $address - global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR - i32.div_u - i32.const 1 - i32.sub - local.set $index - local.get $index - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/JumpTable#get:jumps - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.PANIC - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return + local.set $hasMetadata end - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/JumpTable#get:jumps + local.get $program local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store offset=4 + i32.store local.get $5 - local.get $index - call $~lib/staticarray/StaticArray#__get - local.set $newPc - local.get $newPc - global.get $assembly/interpreter/MAX_U32 - i64.ge_u - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.PANIC - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $r + local.get $pc + local.get $initialGas + local.get $args local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 i32.store offset=4 local.get $5 - local.get $newPc - i32.wrap_i64 - call $assembly/interpreter/DjumpResult#set:newPc - local.get $r - local.set $5 + local.get $hasMetadata + call $assembly/api-debugger/resetJAM global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 - return ) - (func $assembly/interpreter/BranchResult#constructor (param $this i32) (result i32) - (local $1 i32) + (func $assembly/api-debugger/fillRegisters (param $registers i32) (param $flat i32) + (local $len i32) + (local $3 i32) + (local $4 i32) + (local $i i32) + (local $num i64) + (local $j i32) + (local $index i32) + (local $9 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 56 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/interpreter/BranchResult#set:isOkay - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/interpreter/BranchResult#set:newPc - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/program/BasicBlocks#isStart (param $this i32) (param $newPc i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 - i64.store - local.get $newPc - local.get $this - local.set $2 + i64.store offset=8 + local.get $registers + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $2 + local.get $9 + i32.store + local.get $9 + call $~lib/staticarray/StaticArray#get:length + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + local.set $len + local.get $len + local.get $flat + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $9 i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i32.lt_u + local.get $9 + call $~lib/array/Array#get:length + i32.ne if - local.get $this - local.set $2 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $2 + local.get $flat + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/array/Array#get:length + i32.const 10 + call $~lib/number/I32#toString + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $len + i32.const 10 + call $~lib/number/I32#toString + local.tee $4 + i32.store offset=8 + i32.const 18560 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 1 + local.get $3 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18560 + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $9 i32.store - local.get $2 - local.get $newPc - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.START - i32.and - i32.const 0 - i32.gt_s - local.set $2 + local.get $9 + i32.const 3 + local.get $4 + local.set $9 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 18560 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 14480 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 18336 + i32.const 192 + i32.const 5 + call $~lib/builtins/abort + unreachable end i32.const 0 - local.set $2 + local.set $i + loop $for-loop|0 + local.get $i + local.get $registers + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + i64.const 0 + local.set $num + i32.const 0 + local.set $j + loop $for-loop|1 + local.get $j + global.get $assembly/registers/REG_SIZE_BYTES + i32.const 255 + i32.and + i32.lt_u + if + local.get $i + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + local.get $j + i32.add + local.set $index + local.get $num + local.get $flat + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $index + call $~lib/array/Array#__get + i64.extend_i32_u + local.get $j + i32.const 8 + i32.mul + i32.const 255 + i32.and + i64.extend_i32_u + i64.shl + i64.or + local.set $num + local.get $j + i32.const 1 + i32.add + local.set $j + br $for-loop|1 + end + end + local.get $registers + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $i + local.get $num + call $~lib/staticarray/StaticArray#__set + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 - return ) - (func $assembly/interpreter/branch (param $basicBlocks i32) (param $pc i32) (param $offset i32) (result i32) - (local $r i32) - (local $newPc i32) - (local $5 i32) + (func $assembly/interpreter/Interpreter#constructor@varargs (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer i32.const 0 - call $assembly/interpreter/BranchResult#constructor - local.tee $r - i32.store - local.get $pc - local.get $offset - i32.add - local.set $newPc - local.get $basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $newPc - call $assembly/program/BasicBlocks#isStart - if - local.get $r - local.set $5 + i32.const 20 + memory.fill + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 2 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - call $assembly/interpreter/BranchResult#set:isOkay - local.get $r - local.set $5 + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $assembly/memory/MemoryBuilder#build + local.tee $memory i32.store offset=4 - local.get $5 - local.get $newPc - call $assembly/interpreter/BranchResult#set:newPc end - local.get $r - local.set $5 + local.get $this + local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $4 + i32.store + local.get $4 + local.get $program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=16 + local.get $4 + call $assembly/interpreter/Interpreter#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 - return + local.get $4 ) - (func $assembly/interpreter/Interpreter#nextStep (param $this i32) (result i32) - (local $pc i32) - (local $instruction i32) - (local $iData i32) - (local $skipBytes i32) - (local $args i32) - (local $alloc i64) - (local $gas i64) - (local $exe i32) - (local $outcome i32) - (local $10 i32) - (local $res i32) - (local $branchResult i32) - (local $branchResult|13 i32) - (local $14 i32) + (func $assembly/api-debugger/resetGeneric (param $program i32) (param $flatRegisters i32) (param $initialGas i64) (param $hasMetadata i32) + (local $code i32) + (local $p i32) + (local $registers i32) + (local $int i32) + (local $8 i32) + (local $9 i32) global.get $~lib/memory/__stack_pointer - i32.const 40 + i32.const 32 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 40 + i32.const 32 memory.fill - local.get $this - local.set $14 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:status - global.get $assembly/interpreter/Status.HOST - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OK - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 + local.get $hasMetadata + if (result i32) + local.get $program + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/program/liftBytes + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $9 i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:nextPc - call $assembly/interpreter/Interpreter#set:pc - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const -1 - call $assembly/interpreter/Interpreter#set:nextPc - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:status - global.get $assembly/interpreter/Status.OK - i32.ne - if - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:nextPc - i32.const -1 - i32.ne - if - local.get $this - local.set $14 + local.get $9 + call $assembly/program/extractCodeAndMetadata + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $9 i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:nextPc - call $assembly/interpreter/Interpreter#set:pc - local.get $this - local.set $14 + local.get $9 + call $assembly/program/CodeAndMetadata#get:code + else + local.get $program + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $9 i32.store - local.get $14 - i32.const -1 - call $assembly/interpreter/Interpreter#set:nextPc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return + local.get $9 + call $assembly/program/liftBytes end - local.get $this - local.set $14 + local.tee $code + i32.store offset=12 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const 0 - call $assembly/interpreter/Interpreter#set:exitCode - local.get $this - local.set $14 + local.get $code + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $9 i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:pc - local.set $pc - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 + local.get $9 + call $assembly/program/deblob + local.tee $p + i32.store offset=16 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=20 + local.get $registers + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $9 i32.store - local.get $14 - local.get $pc - call $assembly/program/Mask#isInstruction - i32.eqz - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $assembly/instructions/Instruction#get:gas - call $assembly/gas/GasCounter#sub@override - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OOG - call $assembly/interpreter/Interpreter#set:status - else - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - end - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 + local.get $9 + local.get $flatRegisters + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $9 i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 + local.get $9 + call $assembly/api-debugger/fillRegisters global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - call $~lib/typedarray/Uint8Array#__get - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 + i32.const 0 + local.get $p + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $9 i32.store - local.get $14 - call $~lib/array/Array#get:length - i32.lt_s - if (result i32) - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $instruction - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION - end - local.set $iData - local.get $this - local.set $14 + local.get $9 + local.get $registers + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 2 + global.set $~argumentsLength + i32.const 0 + call $assembly/interpreter/Interpreter#constructor@varargs + local.tee $int + i32.store offset=24 + local.get $int + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $9 i32.store offset=4 - local.get $14 + local.get $9 call $assembly/interpreter/Interpreter#get:gas - local.set $14 + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $9 i32.store - local.get $14 - local.get $iData - call $assembly/instructions/Instruction#get:gas - call $assembly/gas/GasCounter#sub@override + local.get $9 + local.get $initialGas + call $assembly/gas/GasCounter#set@override + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.ne if - local.get $this - local.set $14 global.get $~lib/memory/__stack_pointer - local.get $14 + global.get $assembly/api-debugger/interpreter + local.tee $8 + i32.store offset=28 + local.get $8 + if (result i32) + local.get $8 + else + i32.const 9488 + i32.const 18336 + i32.const 38 + i32.const 19 + call $~lib/builtins/abort + unreachable + end + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $assembly/interpreter/Interpreter#get:memory + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 i32.store - local.get $14 - global.get $assembly/interpreter/Status.OOG - call $assembly/interpreter/Interpreter#set:status + local.get $9 + call $assembly/memory/Memory#free + end + local.get $int + global.set $assembly/api-debugger/interpreter + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-debugger/resetGeneric@varargs (param $program i32) (param $flatRegisters i32) (param $initialGas i64) (param $hasMetadata i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 3 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return + local.set $hasMetadata end - local.get $iData - global.get $assembly/instructions/MISSING_INSTRUCTION - i32.eq + local.get $program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $flatRegisters + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $initialGas + local.get $hasMetadata + call $assembly/api-debugger/resetGeneric + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-internal/InitialPage#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz if - local.get $this - local.set $14 global.get $~lib/memory/__stack_pointer - local.get $14 + i32.const 12 + i32.const 48 + call $~lib/rt/itcms/__new + local.tee $this i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return end + global.get $~lib/memory/__stack_pointer local.get $this - local.set $14 + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $1 i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 + local.get $1 + i32.const 0 + call $assembly/api-internal/InitialPage#set:address + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipBytes + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/api-internal/InitialPage#set:length + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:kind + local.get $1 + i32.store offset=4 + local.get $1 + global.get $assembly/memory-page/Access.None + call $assembly/api-internal/InitialPage#set:access local.get $this - local.set $14 + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - local.get $pc + i32.const 0 + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen i32.const 1 i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 i32.const 1 - global.set $~argumentsLength + call $~lib/array/ensureCapacity + i32.const 1 + drop + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-debugger/readPages (param $pageMap i32) (result i32) + (local $1 i32) + (local $pages i32) + (local $codec i32) + (local $p i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $14 + i32.const 20 + memory.fill global.get $~lib/memory/__stack_pointer - local.get $14 + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 18608 + call $~lib/rt/__newArray + local.tee $pages i32.store - local.get $14 - local.get $skipBytes - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=16 - local.get $iData - global.get $assembly/instructions/SBRK - i32.eq - if (result i32) - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:useSbrkGas - else - i32.const 0 - end - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:registers - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - local.set $alloc - local.get $alloc - global.get $assembly/memory-page/PAGE_SIZE - i64.extend_i32_u - i64.add - i64.const 1 - i64.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i64.extend_i32_s - i64.shr_u - i64.const 16 - i64.mul - local.set $gas - local.get $this - local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $pageMap + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $codec + i32.store offset=8 + loop $while-continue|0 + local.get $codec + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $5 i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $gas - call $assembly/gas/GasCounter#sub@override + local.get $5 + call $assembly/codec/Decoder#isExhausted + i32.eqz if - local.get $this - local.set $14 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OOG - call $assembly/interpreter/Interpreter#set:status i32.const 0 - local.set $14 + call $assembly/api-internal/InitialPage#constructor + local.tee $p + i32.store offset=12 + local.get $p + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return + local.get $5 + i32.store offset=4 + local.get $5 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/codec/Decoder#u32 + call $assembly/api-internal/InitialPage#set:address + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/codec/Decoder#u32 + call $assembly/api-internal/InitialPage#set:length + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $codec + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $assembly/codec/Decoder#u8 + i32.const 0 + i32.gt_u + if (result i32) + global.get $assembly/memory-page/Access.Write + else + global.get $assembly/memory-page/Access.Read + end + call $assembly/api-internal/InitialPage#set:access + local.get $pages + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $p + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $5 + call $~lib/array/Array#push + drop + br $while-continue|0 end end + local.get $pages + local.set $5 global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions-exe/RUN - local.set $14 + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $assembly/api-internal/InitialChunk#constructor (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - local.get $14 + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 50 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/object/Object#constructor + local.tee $this i32.store - local.get $14 - local.get $instruction - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get - local.tee $exe - i32.store offset=20 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + call $assembly/api-internal/InitialChunk#set:address + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 18672 + call $~lib/rt/__newArray + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/api-internal/InitialChunk#set:data + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) + (local $oldLen i32) + (local $len i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - local.get $args - local.set $14 + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $14 + i32.const 0 i32.store - local.get $14 local.get $this - local.set $14 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/interpreter/Interpreter#get:registers - local.set $14 + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:length_ + local.set $oldLen + local.get $oldLen + i32.const 1 + i32.add + local.set $len + local.get $this + local.get $len + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + i32.const 1 + drop + local.get $this + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array#get:dataStart + local.get $oldLen + i32.const 2 + i32.shl + i32.add + local.get $value + i32.store local.get $this - local.set $14 + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/interpreter/Interpreter#get:memory - local.set $14 + local.get $4 + i32.store + local.get $4 + local.get $len + call $~lib/array/Array#set:length_ + local.get $len + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $14 + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-debugger/readChunks (param $chunks i32) (result i32) + (local $1 i32) + (local $res i32) + (local $codec i32) + (local $c i32) + (local $len i32) + (local $data i32) + (local $i i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 51 + i32.const 18640 + call $~lib/rt/__newArray + local.tee $res + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $chunks + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + call $assembly/codec/Decoder#constructor + local.tee $codec i32.store offset=8 - local.get $14 - i32.const 3 - global.set $~argumentsLength - local.get $exe - i32.load - call_indirect (type $2) - local.tee $outcome - i32.store offset=24 - block $break|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:outcome - local.set $10 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.DynamicJump - i32.eq - br_if $case0|0 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.StaticJump - i32.eq - br_if $case1|0 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.Result - i32.eq - br_if $case2|0 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.Ok - i32.eq - br_if $case3|0 - br $break|0 - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:jumpTable - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:dJump - call $assembly/interpreter/dJump - local.tee $res - i32.store offset=28 - local.get $res - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/DjumpResult#get:status - global.get $assembly/interpreter/DjumpStatus.HALT - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.HALT - call $assembly/interpreter/Interpreter#set:status - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $res - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/DjumpResult#get:status - global.get $assembly/interpreter/DjumpStatus.PANIC - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:basicBlocks - local.set $14 + loop $while-continue|0 + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-internal/InitialChunk#constructor + local.tee $c + i32.store offset=12 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $assembly/codec/Decoder#u32 + call $assembly/api-internal/InitialChunk#set:address + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/codec/Decoder#u32 + local.set $len + global.get $~lib/memory/__stack_pointer + local.get $codec + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $len + call $assembly/codec/Decoder#bytes + local.tee $data + i32.store offset=20 + i32.const 0 + local.set $i + loop $for-loop|1 + local.get $i + local.get $len + i32.lt_u + if + local.get $c + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $res - local.set $14 + local.get $8 + i32.store offset=16 + local.get $8 + call $assembly/api-internal/InitialChunk#get:data + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $8 i32.store offset=4 - local.get $14 - call $assembly/interpreter/DjumpResult#get:newPc - i32.const 0 - call $assembly/interpreter/branch - local.tee $branchResult - i32.store offset=32 - local.get $branchResult - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/BranchResult#get:isOkay - i32.eqz - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $branchResult - local.set $14 + local.get $8 + local.get $data + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/BranchResult#get:newPc - call $assembly/interpreter/Interpreter#set:pc + local.get $8 + i32.store offset=16 + local.get $8 + local.get $i + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#push + drop + local.get $i i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:basicBlocks - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:staticJump - call $assembly/interpreter/branch - local.tee $branchResult|13 - i32.store offset=36 - local.get $branchResult|13 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/BranchResult#get:isOkay - i32.eqz - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return + local.set $i + br $for-loop|1 end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $branchResult|13 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/BranchResult#get:newPc - call $assembly/interpreter/Interpreter#set:pc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return end - local.get $outcome - local.set $14 + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $c + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $~lib/array/Array#push + drop + br $while-continue|0 + end + end + local.get $res + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 14704 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz + if + i32.const 14704 + i32.const 8128 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/api-internal/buildMemory (param $builder i32) (param $pages i32) (param $chunks i32) (result i32) + (local $sbrkIndex i32) + (local $i i32) + (local $initPage i32) + (local $i|6 i32) + (local $initChunk i32) + (local $data i32) + (local $i|9 i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $assembly/memory-page/RESERVED_MEMORY + local.set $sbrkIndex + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pages + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/array/Array#get:length + i32.lt_s + if global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $pages + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.HOST - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.HOST - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - call $assembly/interpreter/Interpreter#set:exitCode - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:pc - i32.const 1 - i32.add - local.get $skipBytes - i32.add - call $assembly/interpreter/Interpreter#set:nextPc - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $outcome - local.set $14 + local.get $10 + local.get $i + call $~lib/array/Array#__get + local.tee $initPage + i32.store offset=4 + local.get $builder + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $10 i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.FAULT + local.get $10 + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-internal/InitialPage#get:access + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-internal/InitialPage#get:address + i32.const 0 + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-internal/InitialPage#get:length + call $~lib/typedarray/Uint8Array#constructor + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/MemoryBuilder#setData + drop + local.get $initPage + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/api-internal/InitialPage#get:access + global.get $assembly/memory-page/Access.Write i32.eq if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i64.const 1 - call $assembly/gas/GasCounter#sub@override - drop - local.get $outcome - local.set $14 + local.get $initPage + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $10 i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - global.get $assembly/memory-page/RESERVED_MEMORY + local.get $10 + call $assembly/api-internal/InitialPage#get:address + local.get $sbrkIndex i32.lt_u - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status + if (result i32) + local.get $sbrkIndex else - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.FAULT - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 + local.get $initPage + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $10 i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - call $assembly/interpreter/Interpreter#set:exitCode + local.get $10 + call $assembly/api-internal/InitialPage#get:address end - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return + local.set $sbrkIndex end - local.get $outcome - local.set $14 + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + i32.const 0 + local.set $i|6 + loop $for-loop|1 + local.get $i|6 + local.get $chunks + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/array/Array#get:length + i32.lt_s + if global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $chunks + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.FAULT_ACCESS - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i64.const 1 - call $assembly/gas/GasCounter#sub@override - drop - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $outcome - local.set $14 + local.get $10 + local.get $i|6 + call $~lib/array/Array#__get + local.tee $initChunk + i32.store offset=16 global.get $~lib/memory/__stack_pointer - local.get $14 + i32.const 0 + local.get $initChunk + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/api-internal/InitialChunk#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.PANIC - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 + local.get $10 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $data + i32.store offset=20 + i32.const 0 + local.set $i|9 + loop $for-loop|2 + local.get $i|9 + local.get $data + local.set $10 global.get $~lib/memory/__stack_pointer - local.get $14 + local.get $10 i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - call $assembly/interpreter/Interpreter#set:exitCode - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $i|9 + local.get $initChunk + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-internal/InitialChunk#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + local.get $i|9 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $i|9 + i32.const 1 + i32.add + local.set $i|9 + br $for-loop|2 + end end - i32.const 18944 - i32.const 18992 - i32.const 173 - i32.const 9 - call $~lib/builtins/abort - unreachable + local.get $builder + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + global.get $assembly/memory-page/Access.None + local.get $initChunk + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/api-internal/InitialChunk#get:address + local.get $data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/MemoryBuilder#setData + drop + local.get $i|6 + i32.const 1 + i32.add + local.set $i|6 + br $for-loop|1 end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:pc - i32.const 1 - local.get $skipBytes - i32.add - i32.add - call $assembly/interpreter/Interpreter#set:pc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return end - i32.const 0 - local.set $14 + local.get $builder + local.set $10 global.get $~lib/memory/__stack_pointer - i32.const 40 + local.get $10 + i32.store + local.get $10 + local.get $sbrkIndex + call $assembly/memory/MemoryBuilder#build + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 i32.add global.set $~lib/memory/__stack_pointer - local.get $14 + local.get $10 return ) - (func $assembly/api-generic/VmOutput#constructor (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) + (func $assembly/api-debugger/resetGenericWithMemory (param $program i32) (param $flatRegisters i32) (param $pageMap i32) (param $chunks i32) (param $initialGas i64) (param $hasMetadata i32) + (local $code i32) + (local $p i32) + (local $registers i32) + (local $builder i32) + (local $memory i32) + (local $int i32) + (local $12 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 40 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if + i32.const 40 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $hasMetadata + if (result i32) + local.get $program + local.set $12 global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 44 - call $~lib/rt/itcms/__new - local.tee $this + local.get $12 + i32.store offset=8 + local.get $12 + call $assembly/program/liftBytes + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=4 + local.get $12 + call $assembly/program/extractCodeAndMetadata + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store + local.get $12 + call $assembly/program/CodeAndMetadata#get:code + else + local.get $program + local.set $12 + global.get $~lib/memory/__stack_pointer + local.get $12 i32.store + local.get $12 + call $assembly/program/liftBytes end + local.tee $code + i32.store offset=12 global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 + local.get $code + local.set $12 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/object/Object#constructor - local.tee $this + local.get $12 i32.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - global.get $assembly/interpreter/Status.OK - call $assembly/api-generic/VmOutput#set:status - local.get $this - local.set $3 + local.get $12 + call $assembly/program/deblob + local.tee $p + i32.store offset=16 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 i32.const 0 - i32.const 3 - i32.const 43 - i32.const 19072 - call $~lib/rt/__newArray - local.set $3 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=20 + local.get $registers + local.set $12 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/api-generic/VmOutput#set:registers - local.get $this - local.set $3 + local.get $12 + i32.store + local.get $12 + local.get $flatRegisters + local.set $12 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $12 i32.store offset=4 - local.get $3 - i32.const 0 - call $assembly/api-generic/VmOutput#set:pc - local.get $this - local.set $3 + local.get $12 + call $assembly/api-debugger/fillRegisters global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 i32.const 0 - i32.const 2 - i32.const 46 - i32.const 19104 - call $~lib/rt/__newArray - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/api-generic/VmOutput#set:memory - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i64.const 0 - call $assembly/api-generic/VmOutput#set:gas - local.get $this - local.set $3 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store offset=24 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - call $assembly/api-generic/VmOutput#set:exitCode - local.get $this - local.set $3 + local.get $builder + local.set $12 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#slice<~lib/array/Array> (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $length i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $sourceStart i32) - (local $size i32) - (local $out i32) - (local $outStart i32) - (local $18 i32) + local.get $12 + i32.store + local.get $12 + local.get $pageMap + local.set $12 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check + local.get $12 + i32.store offset=28 + local.get $12 + call $assembly/api-debugger/readPages + local.set $12 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $18 + local.get $12 + i32.store offset=4 + local.get $12 + local.get $chunks + local.set $12 global.get $~lib/memory/__stack_pointer - local.get $18 - i32.store - local.get $18 - call $~lib/staticarray/StaticArray#get:length - local.set $length - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $start - local.get $length - i32.add - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - else - local.get $start - local.tee $6 - local.get $length - local.tee $7 - local.get $6 - local.get $7 - i32.lt_s - select - end - local.set $start - local.get $end - i32.const 0 - i32.lt_s - if (result i32) - local.get $end - local.get $length - i32.add - local.tee $8 - i32.const 0 - local.tee $9 - local.get $8 - local.get $9 - i32.gt_s - select - else - local.get $end - local.tee $10 - local.get $length - local.tee $11 - local.get $10 - local.get $11 - i32.lt_s - select - end - local.set $end - local.get $end - local.get $start - i32.sub - local.tee $12 - i32.const 0 - local.tee $13 local.get $12 - local.get $13 - i32.gt_s - select - local.set $length - local.get $this - local.get $start - i32.const 3 - i32.shl - i32.add - local.set $sourceStart - local.get $length - i32.const 3 - i32.shl - local.set $size + i32.store offset=28 + local.get $12 + call $assembly/api-debugger/readChunks + local.set $12 global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $out - i32.store offset=4 - i32.const 1 - drop + local.get $12 + i32.store offset=8 + local.get $12 + call $assembly/api-internal/buildMemory + local.tee $memory + i32.store offset=32 global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 3 - i32.const 43 i32.const 0 - call $~lib/rt/__newArray - local.tee $out - i32.store offset=4 - local.get $out - local.set $18 + local.get $p + local.set $12 global.get $~lib/memory/__stack_pointer - local.get $18 + local.get $12 i32.store - local.get $18 - call $~lib/array/Array#get:dataStart - local.set $outStart - i32.const 0 - drop - local.get $outStart - local.get $sourceStart - local.get $size - memory.copy - local.get $out - local.set $18 + local.get $12 + local.get $registers + local.set $12 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - ) - (func $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $3 i32) + local.get $12 + i32.store offset=4 + local.get $12 + local.get $memory + local.set $12 global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check + local.get $12 + i32.store offset=8 + local.get $12 + call $assembly/interpreter/Interpreter#constructor + local.tee $int + i32.store offset=36 + local.get $int + local.set $12 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $3 + local.get $12 + i32.store offset=4 + local.get $12 + call $assembly/interpreter/Interpreter#get:gas + local.set $12 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $12 i32.store - local.get $3 - local.get $start - local.get $end - call $~lib/staticarray/StaticArray#slice<~lib/array/Array> - local.set $3 + local.get $12 + local.get $initialGas + call $assembly/gas/GasCounter#set@override + local.get $int + global.set $assembly/api-debugger/interpreter global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 40 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 ) - (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $bufferSize i32) - (local $buffer i32) + (func $assembly/api-debugger/resetGenericWithMemory@varargs (param $program i32) (param $flatRegisters i32) (param $pageMap i32) (param $chunks i32) (param $initialGas i64) (param $hasMetadata i32) (local $6 i32) global.get $~lib/memory/__stack_pointer i32.const 16 @@ -36689,164 +36744,339 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 42 - call $~lib/rt/itcms/__new - local.tee $this - i32.store + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 5 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + i32.const 0 + local.set $hasMetadata end - local.get $this + local.get $program local.set $6 global.get $~lib/memory/__stack_pointer local.get $6 - i32.store offset=4 + i32.store local.get $6 - i32.const 0 - call $~lib/array/Array#set:buffer - local.get $this + local.get $flatRegisters local.set $6 global.get $~lib/memory/__stack_pointer local.get $6 i32.store offset=4 local.get $6 - i32.const 0 - call $~lib/array/Array#set:dataStart - local.get $this + local.get $pageMap local.set $6 global.get $~lib/memory/__stack_pointer local.get $6 - i32.store offset=4 + i32.store offset=8 local.get $6 - i32.const 0 - call $~lib/array/Array#set:byteLength - local.get $this + local.get $chunks local.set $6 global.get $~lib/memory/__stack_pointer local.get $6 - i32.store offset=4 + i32.store offset=12 local.get $6 - i32.const 0 - call $~lib/array/Array#set:length_ - local.get $length - i32.const 1073741820 + local.get $initialGas + local.get $hasMetadata + call $assembly/api-debugger/resetGenericWithMemory + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get (param $this i32) (param $index i32) (result i32) + (local $value i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart + local.get $index i32.const 2 - i32.shr_u - i32.gt_u + i32.shl + i32.add + i32.load + local.tee $value + i32.store offset=4 + i32.const 1 + drop + i32.const 0 + i32.eqz + drop + local.get $value + i32.eqz if - i32.const 8176 + i32.const 14704 i32.const 8128 - i32.const 70 - i32.const 60 + i32.const 118 + i32.const 40 call $~lib/builtins/abort unreachable end - local.get $length - local.tee $2 + local.get $value + local.set $3 + global.get $~lib/memory/__stack_pointer i32.const 8 - local.tee $3 - local.get $2 + i32.add + global.set $~lib/memory/__stack_pointer local.get $3 - i32.gt_u - select - i32.const 2 - i32.shl - local.set $bufferSize + return + ) + (func $assembly/interpreter/DjumpResult#constructor (param $this i32) (result i32) + (local $1 i32) global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $6 + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - local.set $6 + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 52 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $~lib/array/Array#set:buffer local.get $this - local.set $6 + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $1 i32.store offset=4 - local.get $6 - local.get $buffer - call $~lib/array/Array#set:dataStart + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store local.get $this - local.set $6 + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $1 i32.store offset=4 - local.get $6 - local.get $bufferSize - call $~lib/array/Array#set:byteLength + local.get $1 + global.get $assembly/interpreter/DjumpStatus.OK + call $assembly/interpreter/DjumpResult#set:status local.get $this - local.set $6 + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $1 i32.store offset=4 - local.get $6 - local.get $length - call $~lib/array/Array#set:length_ + local.get $1 + i32.const 0 + call $assembly/interpreter/DjumpResult#set:newPc local.get $this - local.set $6 + local.set $1 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $6 + local.get $1 ) - (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) - (local $2 i32) + (func $assembly/interpreter/dJump (param $jumpTable i32) (param $address i32) (result i32) + (local $r i32) + (local $index i32) + (local $newPc i64) + (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer i32.const 0 + call $assembly/interpreter/DjumpResult#constructor + local.tee $r i32.store - local.get $this - local.get $newLength - i32.const 2 + local.get $address + global.get $assembly/interpreter/EXIT + i32.eq + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.HALT + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $address i32.const 0 - call $~lib/array/ensureCapacity - local.get $this - local.set $2 + i32.eq + if (result i32) + i32.const 1 + else + local.get $address + global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR + i32.rem_u + i32.const 0 + i32.ne + end + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.PANIC + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $address + global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR + i32.div_u + i32.const 1 + i32.sub + local.set $index + local.get $index + local.get $jumpTable + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $newLength - call $~lib/array/Array#set:length_ + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/JumpTable#get:jumps + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $5 + i32.store offset=4 + local.get $5 + call $~lib/staticarray/StaticArray#get:length + i32.ge_u + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.PANIC + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $jumpTable + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/program/JumpTable#get:jumps + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $index + call $~lib/staticarray/StaticArray#__get + local.set $newPc + local.get $newPc + global.get $assembly/interpreter/MAX_U32 + i64.ge_u + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + global.get $assembly/interpreter/DjumpStatus.PANIC + call $assembly/interpreter/DjumpResult#set:status + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $newPc + i32.wrap_i64 + call $assembly/interpreter/DjumpResult#set:newPc + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer + local.get $5 + return ) - (func $"~lib/map/Map#keys" (param $this i32) (result i32) - (local $start i32) - (local $size i32) - (local $keys i32) - (local $length i32) - (local $i i32) - (local $entry i32) - (local $7 i32) - (local $8 i32) + (func $assembly/interpreter/BranchResult#constructor (param $this i32) (result i32) + (local $1 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -36856,910 +37086,1261 @@ i64.const 0 i64.store local.get $this - local.set $8 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 53 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.set $start local.get $this - local.set $8 + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $8 + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.set $size + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $size - call $~lib/array/Array#constructor - local.tee $keys + local.get $1 i32.store offset=4 + local.get $1 i32.const 0 - local.set $length - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $size - i32.lt_s - if - local.get $start - local.get $i - block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.6" - end - i32.mul - i32.add - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $keys - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - local.tee $7 - i32.const 1 - i32.add - local.set $length - local.get $7 - local.get $entry - call $"~lib/map/MapEntry#get:key" - call $~lib/array/Array#__set - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $keys - local.set $8 + call $assembly/interpreter/BranchResult#set:isOkay + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - call $~lib/array/Array#set:length - local.get $keys - local.set $8 + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/interpreter/BranchResult#set:newPc + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $8 - return + local.get $1 ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) + (func $assembly/program/BasicBlocks#isStart (param $this i32) (param $newPc i32) (result i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store + i64.const 0 + i64.store + local.get $newPc local.get $this - local.set $1 + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 + local.get $2 + call $~lib/staticarray/StaticArray#get:length + i32.lt_u + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/program/BasicBlocks#get:isStartOrEnd + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $newPc + call $~lib/staticarray/StaticArray#__get + global.get $assembly/program/BasicBlock.START + i32.and + i32.const 0 + i32.gt_s + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 0 + local.set $2 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $1 + local.get $2 return ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) + (func $assembly/interpreter/branch (param $basicBlocks i32) (param $pc i32) (param $offset i32) (result i32) + (local $r i32) + (local $newPc i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity i32.const 0 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 + call $assembly/interpreter/BranchResult#constructor + local.tee $r i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 0 - i32.shl + local.get $pc + local.get $offset i32.add - local.get $value - i32.store8 - local.get $this - local.set $4 + local.set $newPc + local.get $basicBlocks + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 + local.get $5 + i32.store offset=4 + local.get $5 + local.get $newPc + call $assembly/program/BasicBlocks#isStart + if + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + i32.const 1 + call $assembly/interpreter/BranchResult#set:isOkay + local.get $r + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + local.get $5 + local.get $newPc + call $assembly/interpreter/BranchResult#set:newPc + end + local.get $r + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $5 return ) - (func $assembly/api-generic/InitialChunk#constructor (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) + (func $assembly/interpreter/Interpreter#nextStep (param $this i32) (result i32) + (local $pc i32) + (local $instruction i32) + (local $iData i32) + (local $skipBytes i32) + (local $args i32) + (local $alloc i64) + (local $gas i64) + (local $exe i32) + (local $outcome i32) + (local $10 i32) + (local $res i32) + (local $branchResult i32) + (local $branchResult|13 i32) + (local $14 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 40 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 + i32.const 40 + memory.fill local.get $this - i32.eqz + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:status + global.get $assembly/interpreter/Status.HOST + i32.eq if + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 45 - call $~lib/rt/itcms/__new - local.tee $this + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OK + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:nextPc + call $assembly/interpreter/Interpreter#set:pc + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 i32.store + local.get $14 + i32.const -1 + call $assembly/interpreter/Interpreter#set:nextPc end + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:status + global.get $assembly/interpreter/Status.OK + i32.ne + if + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end local.get $this - local.set $2 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/object/Object#constructor - local.tee $this + local.get $14 i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:nextPc + i32.const -1 + i32.ne + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:nextPc + call $assembly/interpreter/Interpreter#set:pc + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const -1 + call $assembly/interpreter/Interpreter#set:nextPc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end local.get $this - local.set $2 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 + local.get $14 + i32.store + local.get $14 i32.const 0 - call $assembly/api-generic/InitialChunk#set:address + call $assembly/interpreter/Interpreter#set:exitCode local.get $this - local.set $2 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 19168 - call $~lib/rt/__newArray - local.set $2 + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:pc + local.set $pc + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $14 i32.store offset=8 - local.get $2 - call $assembly/api-generic/InitialChunk#set:data + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $pc + call $assembly/program/Mask#isInstruction + i32.eqz + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/instructions/MISSING_INSTRUCTION + call $assembly/instructions/Instruction#get:gas + call $assembly/gas/GasCounter#sub@override + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OOG + call $assembly/interpreter/Interpreter#set:status + else + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + end + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end local.get $this - local.set $2 + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 0 + local.get $14 i32.store - local.get $index + local.get $14 + local.get $pc + call $~lib/typedarray/Uint8Array#__get + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $~lib/array/Array#get:length + i32.lt_s + if (result i32) + global.get $assembly/instructions/INSTRUCTIONS + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $instruction + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $iData local.get $this - local.set $3 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u + local.get $14 + local.get $iData + call $assembly/instructions/Instruction#get:gas + call $assembly/gas/GasCounter#sub@override if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end local.get $this - local.get $index - i32.const 1 - i32.add + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OOG + call $assembly/interpreter/Interpreter#set:status i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $iData + global.get $assembly/instructions/MISSING_INSTRUCTION + i32.eq + if local.get $this - local.set $3 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $14 i32.store - local.get $3 - local.get $index - i32.const 1 + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 i32.add - call $~lib/array/Array#set:length_ + global.set $~lib/memory/__stack_pointer + local.get $14 + return end local.get $this - local.set $3 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:mask + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 0 - i32.shl + local.get $14 + local.get $pc + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipBytes + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/program/Program#get:code + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + local.get $pc + i32.const 1 i32.add - local.get $value - i32.store8 + i32.const 1 + global.set $~argumentsLength i32.const 0 - drop + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) + local.get $14 + i32.store + local.get $14 + local.get $skipBytes + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=16 + local.get $iData + global.get $assembly/instructions/SBRK + i32.eq + if (result i32) + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/Interpreter#get:useSbrkGas + else + i32.const 0 + end + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:registers + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $args + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i64.extend_i32_u + local.set $alloc + local.get $alloc + global.get $assembly/memory-page/PAGE_SIZE + i64.extend_i32_u + i64.add + i64.const 1 + i64.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i64.extend_i32_u + i64.shr_u + i64.const 16 + i64.mul + local.set $gas + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $gas + call $assembly/gas/GasCounter#sub@override + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.OOG + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + end global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check + global.get $assembly/instructions-exe/RUN + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 0 + local.get $14 i32.store - local.get $this - local.set $4 + local.get $14 + local.get $instruction + call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get + local.tee $exe + i32.store offset=20 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 + local.get $args + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value + local.get $14 i32.store + local.get $14 local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api-generic/getOutputChunks (param $memory i32) (result i32) - (local $1 i32) - (local $chunks i32) - (local $pages i32) - (local $currentChunk i32) - (local $i i32) - (local $pageIdx i32) - (local $page i32) - (local $n i32) - (local $v i32) - (local $10 i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/interpreter/Interpreter#get:registers + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 19136 - call $~lib/rt/__newArray - local.tee $chunks - i32.store + local.get $14 + i32.store offset=4 + local.get $14 + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $11 + local.get $14 + i32.store offset=12 + local.get $14 + call $assembly/interpreter/Interpreter#get:memory + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $11 + local.get $14 i32.store offset=8 - local.get $11 - call $assembly/memory/Memory#get:pages - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $"~lib/map/Map#keys" - local.tee $pages - i32.store offset=12 - i32.const 0 - local.set $currentChunk - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pages - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/array/Array#get:length - i32.lt_s - if - block $for-continue|0 - local.get $pages - local.set $11 + local.get $14 + i32.const 3 + global.set $~argumentsLength + local.get $exe + i32.load + call_indirect (type $2) + local.tee $outcome + i32.store offset=24 + block $break|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:outcome + local.set $10 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.DynamicJump + i32.eq + br_if $case0|0 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.StaticJump + i32.eq + br_if $case1|0 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.Result + i32.eq + br_if $case2|0 + local.get $10 + global.get $assembly/instructions/outcome/Outcome.Ok + i32.eq + br_if $case3|0 + br $break|0 + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:jumpTable + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:dJump + call $assembly/interpreter/dJump + local.tee $res + i32.store offset=28 + local.get $res + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/DjumpResult#get:status + global.get $assembly/interpreter/DjumpStatus.HALT + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.HALT + call $assembly/interpreter/Interpreter#set:status + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $res + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/DjumpResult#get:status + global.get $assembly/interpreter/DjumpStatus.PANIC + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:basicBlocks + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $res + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/DjumpResult#get:newPc + i32.const 0 + call $assembly/interpreter/branch + local.tee $branchResult + i32.store offset=32 + local.get $branchResult + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/BranchResult#get:isOkay + i32.eqz + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $branchResult + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/BranchResult#get:newPc + call $assembly/interpreter/Interpreter#set:pc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $assembly/interpreter/Interpreter#get:program + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/program/Program#get:basicBlocks + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $pc + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:staticJump + call $assembly/interpreter/branch + local.tee $branchResult|13 + i32.store offset=36 + local.get $branchResult|13 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/interpreter/BranchResult#get:isOkay + i32.eqz + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $branchResult|13 + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/BranchResult#get:newPc + call $assembly/interpreter/Interpreter#set:pc + i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.HOST + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.HOST + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + call $assembly/interpreter/Interpreter#set:exitCode + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:pc + i32.const 1 + i32.add + local.get $skipBytes + i32.add + call $assembly/interpreter/Interpreter#set:nextPc + i32.const 0 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.FAULT + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i64.const 1 + call $assembly/gas/GasCounter#sub@override + drop + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + global.get $assembly/memory-page/RESERVED_MEMORY + i32.lt_u + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + else + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.FAULT + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + call $assembly/interpreter/Interpreter#set:exitCode + end + i32.const 0 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $11 + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.FAULT_ACCESS + i32.eq + if + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 i32.store offset=4 - local.get $11 - local.get $i - call $~lib/array/Array#__get - local.set $pageIdx + local.get $14 + call $assembly/interpreter/Interpreter#get:gas + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $11 + local.get $14 + i32.store + local.get $14 + i64.const 1 + call $assembly/gas/GasCounter#sub@override + drop + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory/Memory#get:pages - local.set $11 + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + i32.const 0 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $pageIdx - call $"~lib/map/Map#get" - local.tee $page - i32.store offset=16 - local.get $page - local.set $11 + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return + end + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:result + global.get $assembly/instructions/outcome/Result.PANIC + i32.eq + if + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory-page/Page#get:raw - local.set $11 + local.get $14 + i32.store + local.get $14 + global.get $assembly/interpreter/Status.PANIC + call $assembly/interpreter/Interpreter#set:status + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $11 + local.get $14 + i32.store + local.get $14 + local.get $outcome + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 i32.store offset=4 - local.get $11 - call $assembly/memory-page/RawPage#get:page - i32.const 0 - i32.eq - if - br $for-continue|0 - end + local.get $14 + call $assembly/instructions/outcome/OutcomeData#get:exitCode + call $assembly/interpreter/Interpreter#set:exitCode i32.const 0 - local.set $n - loop $for-loop|1 - local.get $n - local.get $page - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=20 - local.get $11 - call $assembly/memory-page/Page#get:raw - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory-page/RawPage#get:data - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $page - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=20 - local.get $11 - call $assembly/memory-page/Page#get:raw - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory-page/RawPage#get:data - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - i32.const 0 - i32.ne - if - local.get $currentChunk - i32.const 0 - i32.ne - if - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/api-generic/InitialChunk#get:data - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $v - call $~lib/array/Array#push - drop - else - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-generic/InitialChunk#constructor - local.tee $currentChunk - i32.store offset=24 - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $pageIdx - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.get $n - i32.add - call $assembly/api-generic/InitialChunk#set:address - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - global.get $~lib/memory/__stack_pointer - i32.const 1 - i32.const 0 - i32.const 27 - i32.const 0 - call $~lib/rt/__newArray - local.tee $10 - i32.store offset=28 - local.get $10 - i32.const 0 - local.get $v - call $~lib/array/Array#__set - local.get $10 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/api-generic/InitialChunk#set:data - end - else - local.get $currentChunk - i32.const 0 - i32.ne - if - local.get $chunks - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/array/Array#push - drop - i32.const 0 - local.set $currentChunk - end - end - local.get $n - i32.const 1 - i32.add - local.set $n - br $for-loop|1 - end - end + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $14 + return end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $currentChunk - i32.const 0 - i32.ne - if - local.get $chunks - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/array/Array#push - drop - end - local.get $chunks - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $bufferSize i32) - (local $buffer i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 57 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:length_ - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8128 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - local.tee $2 - i32.const 8 - local.tee $3 - local.get $2 - local.get $3 - i32.gt_u - select - i32.const 2 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $bufferSize - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $length - call $~lib/array/Array#set:length_ - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 + i32.const 18704 + i32.const 18752 + i32.const 173 + i32.const 9 call $~lib/builtins/abort unreachable end local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $14 i32.store - local.get $3 - local.get $index + local.get $14 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $assembly/interpreter/Interpreter#get:pc + i32.const 1 + local.get $skipBytes + i32.add + i32.add + call $assembly/interpreter/Interpreter#set:pc i32.const 1 + local.set $14 + global.get $~lib/memory/__stack_pointer + i32.const 40 i32.add - call $~lib/array/Array#set:length_ + global.set $~lib/memory/__stack_pointer + local.get $14 + return end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link + i32.const 0 + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 40 i32.add global.set $~lib/memory/__stack_pointer + local.get $14 + return ) - (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) + (func $assembly/api-debugger/nextStep (result i32) + (local $0 i32) + (local $int i32) (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store - local.get $this - local.get $newLength - i32.const 2 + i32.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 18336 + i32.const 69 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/interpreter/Interpreter#nextStep + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end i32.const 0 - call $~lib/array/ensureCapacity - local.get $this local.set $2 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $newLength - call $~lib/array/Array#set:length_ - global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer + local.get $2 + return ) - (func $"~lib/map/Map#values" (param $this i32) (result i32) - (local $start i32) - (local $size i32) - (local $values i32) - (local $length i32) + (func $assembly/api-debugger/nSteps (param $steps i32) (result i32) + (local $1 i32) + (local $int i32) + (local $isOk i32) (local $i i32) - (local $entry i32) - (local $7 i32) - (local $8 i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub @@ -37771,255 +38352,85 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.set $start - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.set $size - global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter i32.const 0 - local.get $size - call $~lib/array/Array#constructor - local.tee $values - i32.store offset=4 - i32.const 0 - local.set $length - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $size - i32.lt_s - if - local.get $start + i32.ne + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 18336 + i32.const 77 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + i32.const 1 + local.set $isOk + i32.const 0 + local.set $i + loop $for-loop|0 local.get $i - block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.7" - end - i32.mul - i32.add - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz + local.get $steps + i32.lt_u if - local.get $values - local.set $8 + local.get $int + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - local.tee $7 + local.get $5 + i32.store offset=8 + local.get $5 + call $assembly/interpreter/Interpreter#nextStep + local.set $isOk + local.get $isOk + i32.eqz + if + i32.const 0 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $i i32.const 1 i32.add - local.set $length - local.get $7 - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/array/Array#__set + local.set $i + br $for-loop|0 end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 end + local.get $isOk + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return end - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - call $~lib/array/Array#set:length - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 16800 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $5 return ) - (func $assembly/memory-page/Arena#release (param $this i32) (param $page i32) + (func $assembly/api-debugger/getProgramCounter (result i32) + (local $0 i32) + (local $int i32) (local $2 i32) global.get $~lib/memory/__stack_pointer i32.const 12 @@ -38032,2143 +38443,2261 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory-page/Arena#get:free - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $page - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/array/Array#push - drop - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#clear" (param $this i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - i32.const 4 - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 4 - i32.const 1 - i32.sub - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 + global.get $assembly/api-debugger/interpreter i32.const 0 - i32.const 4 - block $"~lib/map/ENTRY_SIZE|inlined.8" (result i32) + i32.eq + if + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.8" + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 4 - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $1 global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesOffset" - local.get $this - local.set $1 global.get $~lib/memory/__stack_pointer - local.get $1 + global.get $assembly/api-debugger/interpreter + local.tee $0 i32.store - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesCount" + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 18336 + i32.const 94 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/interpreter/Interpreter#get:pc + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer + local.get $2 + return ) - (func $assembly/memory/Memory#free (param $this i32) - (local $pages i32) - (local $i i32) + (func $assembly/api-debugger/setNextProgramCounter (param $pc i32) + (local $1 i32) + (local $int i32) (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory/Memory#get:pages - local.set $3 + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $"~lib/map/Map#values" - local.tee $pages + i32.const 0 i32.store offset=8 + global.get $assembly/api-debugger/interpreter i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pages - local.set $3 + i32.eq + if global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - i32.lt_s - if - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/memory/Memory#get:arena - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $pages - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $3 - local.get $i - call $~lib/array/Array#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/memory-page/Page#get:raw - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#release - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return end - local.get $this - local.set $3 global.get $~lib/memory/__stack_pointer - local.get $3 + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 18336 + i32.const 102 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int i32.store offset=4 - local.get $3 - call $assembly/memory/Memory#get:pages + local.get $int local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store + i32.store offset=8 local.get $3 - call $"~lib/map/Map#clear" + local.get $pc + call $assembly/interpreter/Interpreter#set:nextPc global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/api-generic/runVm (param $input i32) (param $logs i32) (param $useSbrkGas i32) (result i32) - (local $p i32) - (local $registers i32) - (local $r i32) - (local $builder i32) - (local $memory i32) + (func $assembly/api-debugger/getStatus (result i32) + (local $0 i32) (local $int i32) - (local $isOk i32) - (local $10 i32) - (local $11 i32) - (local $instruction i32) - (local $iData i32) - (local $skipBytes i32) - (local $name i32) - (local $16 i32) - (local $17 i32) - (local $args i32) - (local $19 i32) - (local $20 i32) - (local $21 i32) - (local $22 i32) - (local $23 i32) - (local $24 i32) - (local $25 i32) - (local $26 i32) - (local $27 i32) - (local $28 i32) - (local $29 i32) - (local $30 i32) - (local $output i32) - (local $32 i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 124 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 124 - memory.fill + i32.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.eq + if + global.get $assembly/interpreter/Status.PANIC + i32.const 255 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end global.get $~lib/memory/__stack_pointer - local.get $input - local.set $32 global.get $~lib/memory/__stack_pointer - local.get $32 + global.get $assembly/api-debugger/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 18336 + i32.const 110 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 i32.store offset=8 - local.get $32 - call $assembly/api-generic/VmInput#get:program - local.set $32 + local.get $2 + call $assembly/interpreter/Interpreter#get:status + i32.const 255 + i32.and + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/liftBytes - local.set $32 + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api-debugger/getExitArg (result i32) + (local $0 i32) + (local $int i32) + (local $2 i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $assembly/program/deblob - local.tee $p - i32.store offset=12 + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=16 + i32.store offset=8 + global.get $assembly/api-debugger/interpreter i32.const 0 - local.set $r - loop $for-loop|0 - local.get $r - local.get $registers - local.set $32 + i32.eq + if + i32.const 0 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $r - local.get $input - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/api-generic/VmInput#get:registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $r - call $~lib/array/Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $r - i32.const 1 - i32.add - local.set $r - br $for-loop|0 - end + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return end global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $32 global.get $~lib/memory/__stack_pointer - local.get $32 + global.get $assembly/api-debugger/interpreter + local.tee $0 i32.store - local.get $32 - local.get $input - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/api-generic/VmInput#get:pageMap - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 18336 + i32.const 118 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int i32.store offset=4 - local.get $32 - local.get $input - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/api-generic/VmInput#get:memory - local.set $32 + local.get $int + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $3 i32.store offset=8 - local.get $32 - call $assembly/api-generic/buildMemory - local.tee $memory - i32.store offset=28 + local.get $3 + call $assembly/interpreter/Interpreter#get:exitCode + local.tee $2 + if (result i32) + local.get $2 + else + i32.const 0 + end + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $p - local.set $32 + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/api-debugger/getGasLeft (result i64) + (local $0 i32) + (local $int i32) + (local $2 i32) + (local $3 i64) global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $registers - local.set $32 + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $memory - local.set $32 + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/interpreter/Interpreter#constructor - local.tee $int - i32.store offset=32 - local.get $int - local.set $32 + i64.const 0 + i64.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.eq + if + i64.const 0 + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + end global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $useSbrkGas - call $assembly/interpreter/Interpreter#set:useSbrkGas - local.get $int - local.set $32 global.get $~lib/memory/__stack_pointer - local.get $32 + global.get $assembly/api-debugger/interpreter + local.tee $0 i32.store - local.get $32 - local.get $input - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 18336 + i32.const 126 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int i32.store offset=4 - local.get $32 - call $assembly/api-generic/VmInput#get:pc - call $assembly/interpreter/Interpreter#set:nextPc local.get $int - local.set $32 + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 + local.get $2 + i32.store offset=12 + local.get $2 call $assembly/interpreter/Interpreter#get:gas - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $input - local.set $32 + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/api-generic/VmInput#get:gas - call $assembly/gas/GasCounter#set@override - i32.const 1 - local.set $isOk - block $for-break1 - loop $for-loop|1 - i32.const 1 - if - local.get $isOk - i32.eqz - if - local.get $logs - if - global.get $~lib/memory/__stack_pointer - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 17392 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray#join - local.tee $10 - i32.store offset=36 - i32.const 18128 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 1 - local.get $10 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18128 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 14400 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - global.get $~lib/memory/__stack_pointer - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - i32.const 18192 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=40 - local.get $32 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 17392 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/array/Array<~lib/string/String>#join - local.tee $11 - i32.store offset=44 - i32.const 18160 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 1 - local.get $11 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18160 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 14400 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 18224 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:status - i32.const 10 - call $~lib/number/I32#toString - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/string/String#concat - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - br $for-break1 - end - local.get $logs - if - i32.const 18288 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - i32.const 10 - call $~lib/number/U32#toString - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/string/String#concat - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 18320 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:status - i32.const 10 - call $~lib/number/I32#toString - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/string/String#concat - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 18032 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - i32.const 17392 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=40 - local.get $32 - call $~lib/staticarray/StaticArray#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/string/String#concat - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 18032 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - local.get $registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=48 - local.get $32 - i32.const 18368 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=52 - local.get $32 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - i32.const 17392 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=40 - local.get $32 - call $~lib/array/Array<~lib/string/String>#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/string/String#concat - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end - local.get $logs + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/gas/GasCounter#get@override + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $assembly/api-debugger/setGasLeft (param $gas i64) + (local $1 i32) + (local $int i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 18336 + i32.const 132 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/interpreter/Interpreter#get:gas + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $gas + call $assembly/gas/GasCounter#set@override + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-debugger/getRegisters (result i32) + (local $flat i32) + (local $1 i32) + (local $int i32) + (local $i i32) + (local $val i64) + (local $j i32) + (local $index i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + call $~lib/typedarray/Uint8Array#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.tee $flat + i32.store offset=4 + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.eq + if + local.get $flat + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store offset=8 + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 18336 + i32.const 143 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=12 + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $int + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/interpreter/Interpreter#get:registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/staticarray/StaticArray#get:length + i32.lt_s + if + local.get $int + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/interpreter/Interpreter#get:registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $i + call $~lib/staticarray/StaticArray#__get + local.set $val + i32.const 0 + local.set $j + loop $for-loop|1 + local.get $j + global.get $assembly/registers/REG_SIZE_BYTES + i32.lt_s if - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/interpreter/Interpreter#get:program - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/Program#get:code - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_u - if (result i32) - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/interpreter/Interpreter#get:program - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/Program#get:code - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - call $~lib/typedarray/Uint8Array#__get - else - i32.const 0 - end - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $32 + local.get $i + global.get $assembly/registers/REG_SIZE_BYTES + i32.mul + local.get $j + i32.add + local.set $index + local.get $flat + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $7 i32.store - local.get $32 - call $~lib/array/Array#get:length + local.get $7 + local.get $index + local.get $val + i64.const 255 + i64.and + i32.wrap_i64 i32.const 255 i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $instruction - call $~lib/array/Array#__get - end - local.set $iData - local.get $p - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/Program#get:mask - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipBytes - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:namePtr - local.tee $name - i32.store offset=56 - global.get $~lib/memory/__stack_pointer - local.get $name - local.tee $16 - i32.store offset=60 - global.get $~lib/memory/__stack_pointer - local.get $instruction - i32.const 10 - call $~lib/number/U8#toString - local.tee $17 - i32.store offset=64 - i32.const 18480 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 1 - local.get $16 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18480 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 3 - local.get $17 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18480 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 14400 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=40 - local.get $32 - call $assembly/interpreter/Interpreter#get:program - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/program/Program#get:code - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:pc + call $~lib/typedarray/Uint8Array#__set + local.get $val + i64.const 8 + i64.shr_u + local.set $val + local.get $j i32.const 1 i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $skipBytes - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/interpreter/Interpreter#get:registers - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/resolveArguments - local.tee $args - i32.store offset=68 - local.get $args - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:a - i32.const 10 - call $~lib/number/I64#toString - local.tee $19 - i32.store offset=72 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/program/ResolvedArguments#get:decoded - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/arguments/Args#get:a - i32.const 10 - call $~lib/number/U32#toString - local.tee $20 - i32.store offset=76 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:a - i32.const 16 - call $~lib/number/U64#toString - local.tee $21 - i32.store offset=80 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:b - i32.const 10 - call $~lib/number/I64#toString - local.tee $22 - i32.store offset=84 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/program/ResolvedArguments#get:decoded - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/arguments/Args#get:b - i32.const 10 - call $~lib/number/U32#toString - local.tee $23 - i32.store offset=88 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:b - i32.const 16 - call $~lib/number/U64#toString - local.tee $24 - i32.store offset=92 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:c - i32.const 10 - call $~lib/number/I64#toString - local.tee $25 - i32.store offset=96 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/program/ResolvedArguments#get:decoded - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/arguments/Args#get:c - i32.const 10 - call $~lib/number/U32#toString - local.tee $26 - i32.store offset=100 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:c - i32.const 16 - call $~lib/number/U64#toString - local.tee $27 - i32.store offset=104 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:d - i32.const 10 - call $~lib/number/I64#toString - local.tee $28 - i32.store offset=108 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $assembly/program/ResolvedArguments#get:decoded - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/arguments/Args#get:d - i32.const 10 - call $~lib/number/U32#toString - local.tee $29 - i32.store offset=112 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/program/ResolvedArguments#get:d - i32.const 16 - call $~lib/number/U64#toString - local.tee $30 - i32.store offset=116 - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 1 - local.get $19 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 3 - local.get $20 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 5 - local.get $21 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 7 - local.get $22 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 9 - local.get $23 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 11 - local.get $24 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 13 - local.get $25 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 15 - local.get $26 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 17 - local.get $27 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 19 - local.get $28 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 21 - local.get $29 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 23 - local.get $30 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18816 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - i32.const 14400 - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $~lib/console/console.log - end + local.set $j + br $for-loop|1 end - local.get $int - local.set $32 + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $flat + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $assembly/api-debugger/setRegisters (param $flatRegisters i32) + (local $1 i32) + (local $int i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 18336 + i32.const 160 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + call $assembly/interpreter/Interpreter#get:registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $3 + local.get $flatRegisters + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $3 + call $assembly/api-debugger/fillRegisters + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#pageDump (param $this i32) (param $index i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory/Memory#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $index + call $"~lib/map/Map#has" + i32.eqz + if + i32.const 0 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + call $assembly/memory/Memory#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + local.get $index + call $"~lib/map/Map#get" + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/memory-page/Page#get:raw + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $assembly/memory-page/RawPage#get:data + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api-debugger/getPageDump (param $index i32) (result i32) + (local $1 i32) + (local $int i32) + (local $page i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.eq + if + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store offset=4 + local.get $1 + if (result i32) + local.get $1 + else + i32.const 9488 + i32.const 18336 + i32.const 168 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $int + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/interpreter/Interpreter#get:memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $index + call $assembly/memory/Memory#pageDump + local.tee $page + i32.store offset=16 + local.get $page + i32.const 0 + i32.eq + if + i32.const 0 + global.get $assembly/memory-page/PAGE_SIZE + call $~lib/typedarray/Uint8Array#constructor + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.const 0 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#fill@varargs + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $page + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-debugger/setMemory (param $address i32) (param $data i32) + (local $2 i32) + (local $int i32) + (local $end i32) + (local $i i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $2 + i32.store + local.get $2 + if (result i32) + local.get $2 + else + i32.const 9488 + i32.const 18336 + i32.const 181 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $address + local.get $data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + call $~lib/typedarray/Uint8Array#get:length + i32.add + local.set $end + local.get $address + local.set $i + loop $for-loop|0 + local.get $i + local.get $end + i32.lt_u + if + local.get $int + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/interpreter/Interpreter#get:memory + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $6 + local.get $i + local.get $data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $i + local.get $address + i32.sub + call $~lib/typedarray/Uint8Array#__get + call $assembly/memory/Memory#setU8 + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + ) + (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i64) + (local $value i64) + (local $3 i32) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u + if + i32.const 480 + i32.const 8128 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value + i32.const 0 + drop + local.get $value + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-utils/prepareProgram (param $kind i32) (param $hasMetadata i32) (param $program i32) (param $initialRegisters i32) (param $initialPageMap i32) (param $initialMemory i32) (param $args i32) (result i32) + (local $code i32) + (local $metadata i32) + (local $data i32) + (local $program|10 i32) + (local $builder i32) + (local $memory i32) + (local $registers i32) + (local $r i32) + (local $exe i32) + (local $exe|16 i32) + (local $17 i32) + global.get $~lib/memory/__stack_pointer + i32.const 48 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 48 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $program + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + call $assembly/program/liftBytes + local.tee $code + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.tee $metadata + i32.store offset=8 + local.get $hasMetadata + global.get $assembly/api-utils/HasMetadata.Yes + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $code + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + call $assembly/program/extractCodeAndMetadata + local.tee $data + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + call $assembly/program/CodeAndMetadata#get:code + local.tee $code + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $data + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + call $assembly/program/CodeAndMetadata#get:metadata + local.tee $metadata + i32.store offset=8 + end + local.get $kind + global.get $assembly/api-utils/InputKind.Generic + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $code + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + call $assembly/program/deblob + local.tee $program|10 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/MemoryBuilder#constructor + local.tee $builder + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $builder + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + local.get $initialPageMap + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=24 + local.get $17 + local.get $initialMemory + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=28 + local.get $17 + call $assembly/api-internal/buildMemory + local.tee $memory + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 0 + global.get $assembly/registers/NO_OF_REGISTERS + call $~lib/staticarray/StaticArray#constructor + local.tee $registers + i32.store offset=36 + i32.const 0 + local.set $r + loop $for-loop|0 + local.get $r + local.get $initialRegisters + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + call $~lib/array/Array#get:length + i32.lt_s + if + local.get $registers + local.set $17 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $17 i32.store - local.get $32 - call $assembly/interpreter/Interpreter#nextStep - local.set $isOk - br $for-loop|1 + local.get $17 + local.get $r + local.get $initialRegisters + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=24 + local.get $17 + local.get $r + call $~lib/array/Array#__get + call $~lib/staticarray/StaticArray#__set + local.get $r + i32.const 1 + i32.add + local.set $r + br $for-loop|0 end end + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $program|10 + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + local.get $memory + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=24 + local.get $17 + local.get $registers + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=28 + local.get $17 + call $assembly/spi/StandardProgram#constructor + local.tee $exe + i32.store offset=40 + local.get $exe + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + local.get $metadata + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=24 + local.get $17 + call $assembly/spi/StandardProgram#set:metadata + local.get $exe + local.set $17 + global.get $~lib/memory/__stack_pointer + i32.const 48 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $17 + return end + local.get $kind + global.get $assembly/api-utils/InputKind.SPI + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $code + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + local.get $args + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=28 + local.get $17 + call $assembly/program/liftBytes + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=24 + local.get $17 + call $assembly/spi/decodeSpi + local.tee $exe|16 + i32.store offset=44 + local.get $exe|16 + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store + local.get $17 + local.get $metadata + local.set $17 + global.get $~lib/memory/__stack_pointer + local.get $17 + i32.store offset=24 + local.get $17 + call $assembly/spi/StandardProgram#set:metadata + local.get $exe|16 + local.set $17 + global.get $~lib/memory/__stack_pointer + i32.const 48 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $17 + return + end + i32.const 18960 + local.set $17 global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-generic/VmOutput#constructor - local.tee $output - i32.store offset=120 - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:status - call $assembly/api-generic/VmOutput#set:status - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $17 i32.store - local.get $32 - local.get $int - local.set $32 + local.get $17 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $17 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $17 i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:registers - local.set $32 + local.get $17 + call $~lib/string/String#concat + i32.const 19008 + i32.const 81 + i32.const 3 + call $~lib/builtins/abort + unreachable + ) + (func $"~lib/map/Map#constructor" (param $this i32) (result i32) + (local $1 i32) global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=8 - local.get $32 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs - local.set $32 + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=4 - local.get $32 - call $assembly/api-generic/VmOutput#set:registers - local.get $output - local.set $32 + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.const 57 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $1 i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:pc - call $assembly/api-generic/VmOutput#set:pc - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 + local.get $1 + i32.const 0 + i32.const 4 + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $1 i32.store offset=8 - local.get $32 - call $assembly/interpreter/Interpreter#get:gas - local.set $32 + local.get $1 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $1 i32.store offset=4 - local.get $32 - call $assembly/gas/GasCounter#get@override - call $assembly/api-generic/VmOutput#set:gas - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 + local.get $1 + i32.const 4 + i32.const 1 + i32.sub + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store offset=24 - local.get $32 - call $assembly/interpreter/Interpreter#get:memory - local.set $32 + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.const 4 + block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.0" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $1 i32.store offset=8 - local.get $32 - call $assembly/api-generic/getOutputChunks - local.set $32 + local.get $1 + call $"~lib/map/Map#set:entries" + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $1 i32.store offset=4 - local.get $32 - call $assembly/api-generic/VmOutput#set:memory - local.get $output - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - local.get $int - local.set $32 + local.get $1 + i32.const 4 + call $"~lib/map/Map#set:entriesCapacity" + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $1 i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:exitCode - call $assembly/api-generic/VmOutput#set:exitCode - local.get $int - local.set $32 + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesOffset" + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $32 + local.get $1 i32.store offset=4 - local.get $32 - call $assembly/interpreter/Interpreter#get:memory - local.set $32 - global.get $~lib/memory/__stack_pointer - local.get $32 - i32.store - local.get $32 - call $assembly/memory/Memory#free - local.get $output - local.set $32 + local.get $1 + i32.const 0 + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - i32.const 124 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $32 - return + local.get $1 ) - (func $assembly/index/runProgram (param $input i32) (param $registers i32) (param $kind i32) (result i32) - (local $vmInput i32) - (local $output i32) + (func $"~lib/map/Map#find" (param $this i32) (param $key i32) (param $hashCode i32) (result i32) + (local $entry i32) + (local $taggedNext i32) (local $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 24 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 24 - memory.fill - local.get $kind - global.get $assembly/index/InputKind.Generic - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-generic/VmInput#constructor - local.tee $vmInput - i32.store - local.get $vmInput - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/api-generic/VmInput#set:registers - local.get $vmInput - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i64.const 10000 - call $assembly/api-generic/VmInput#set:gas - local.get $vmInput - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $input - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/api-generic/VmInput#set:program - global.get $~lib/memory/__stack_pointer - local.get $vmInput - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - i32.const 0 - call $assembly/api-generic/runVm - local.tee $output - i32.store offset=12 - i32.const 18224 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $output - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/api-generic/VmOutput#get:status - i32.const 10 - call $~lib/number/I32#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $~lib/string/String#concat - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/console/console.log - local.get $output - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $kind - global.get $assembly/index/InputKind.SPI - i32.eq - if - i32.const 19200 - i32.const 19280 - i32.const 57 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - i32.const 17584 + i32.store + local.get $this local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store offset=4 + i32.store local.get $5 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 - i32.store offset=8 + i32.store local.get $5 - call $~lib/string/String#concat - i32.const 19280 - i32.const 60 - i32.const 3 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-generic/runVm@varargs (param $input i32) (param $logs i32) (param $useSbrkGas i32) (result i32) - (local $3 i32) + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + i32.load + local.set $entry + loop $while-continue|0 + local.get $entry + if + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + local.set $taggedNext + local.get $taggedNext + i32.const 1 + i32.and + i32.eqz + if (result i32) + local.get $entry + call $"~lib/map/MapEntry#get:key" + local.get $key + i32.eq + else + i32.const 0 + end + if + local.get $entry + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + local.get $taggedNext + i32.const 1 + i32.const -1 + i32.xor + i32.and + local.set $entry + br $while-continue|0 + end + end + i32.const 0 + local.set $5 global.get $~lib/memory/__stack_pointer i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + ) + (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) + (local $newBucketsCapacity i32) + (local $newBuckets i32) + (local $newEntriesCapacity i32) + (local $newEntries i32) + (local $oldPtr i32) + (local $oldEnd i32) + (local $newPtr i32) + (local $oldEntry i32) + (local $newEntry i32) + (local $oldEntryKey i32) + (local $newBucketIndex i32) + (local $newBucketPtrBase i32) + (local $14 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $newBucketsMask + i32.const 1 + i32.add + local.set $newBucketsCapacity + global.get $~lib/memory/__stack_pointer i32.const 0 + local.get $newBucketsCapacity + i32.const 4 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newBuckets i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange + local.get $newBucketsCapacity + i32.const 8 + i32.mul + i32.const 3 + i32.div_s + local.set $newEntriesCapacity + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $newEntriesCapacity + block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.1" + end + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $newEntries + i32.store offset=4 + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entries" + local.set $oldPtr + local.get $oldPtr + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.2" + end + i32.mul + i32.add + local.set $oldEnd + local.get $newEntries + local.set $newPtr + loop $while-continue|0 + local.get $oldPtr + local.get $oldEnd + i32.ne + if + local.get $oldPtr + local.set $oldEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $newPtr + local.set $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:key" + local.set $oldEntryKey + local.get $newEntry + local.get $oldEntryKey + call $"~lib/map/MapEntry#set:key" + local.get $newEntry + local.get $oldEntry + call $"~lib/map/MapEntry#get:value" + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=8 + local.get $14 + call $"~lib/map/MapEntry#set:value" + local.get $oldEntryKey + call $~lib/util/hash/HASH + local.get $newBucketsMask + i32.and + local.set $newBucketIndex + local.get $newBuckets + local.get $newBucketIndex + i32.const 4 + i32.mul + i32.add + local.set $newBucketPtrBase + local.get $newEntry + local.get $newBucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $newBucketPtrBase + local.get $newPtr + i32.store + local.get $newPtr + block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.3" end - unreachable + i32.add + local.set $newPtr end - i32.const 0 - local.set $logs + local.get $oldPtr + block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.4" + end + i32.add + local.set $oldPtr + br $while-continue|0 end - i32.const 0 - local.set $useSbrkGas end - local.get $input - local.set $3 + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $logs - local.get $useSbrkGas - call $assembly/api-generic/runVm - local.set $3 + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBuckets + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:buckets" + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newBucketsMask + call $"~lib/map/Map#set:bucketsMask" + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntries + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#set:entries" local.get $this - local.set $3 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end + local.get $14 + i32.store offset=8 + local.get $14 + local.get $newEntriesCapacity + call $"~lib/map/Map#set:entriesCapacity" local.get $this - local.set $3 + local.set $14 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset + local.get $14 + i32.store offset=8 + local.get $14 + local.get $this + local.set $14 global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $14 + i32.store offset=12 + local.get $14 + call $"~lib/map/Map#get:entriesCount" + call $"~lib/map/Map#set:entriesOffset" + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/program-build/skipBytes (param $kind i32) (param $data i32) (result i32) - (local $2 i32) - (local $n i32) - (local $split i32) - (local $n|5 i32) - (local $split|6 i32) - (local $n|7 i32) - (local $split|8 i32) - (local $value1 f64) - (local $value2 f64) - (local $value1|11 f64) - (local $value2|12 f64) - (local $n|13 i32) - (local $split|14 i32) - (local $15 i32) + (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) + (local $hashCode i32) + (local $entry i32) + (local $entries i32) + (local $6 i32) + (local $bucketPtrBase i32) + (local $8 i32) global.get $~lib/memory/__stack_pointer - i32.const 24 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 24 - memory.fill - block $case13|0 - block $case12|0 - block $case11|0 - block $case10|0 - block $case9|0 - block $case8|0 - block $case7|0 - block $case6|0 - block $case5|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $kind - local.set $2 - local.get $2 - global.get $assembly/arguments/Arguments.Zero - i32.eq - br_if $case0|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneImm - i32.eq - br_if $case1|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoImm - i32.eq - br_if $case2|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneOff - i32.eq - br_if $case3|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegOneImm - i32.eq - br_if $case4|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegOneExtImm - i32.eq - br_if $case5|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i32.eq - br_if $case6|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i32.eq - br_if $case7|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoReg - i32.eq - br_if $case8|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i32.eq - br_if $case9|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i32.eq - br_if $case10|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoRegTwoImm - i32.eq - br_if $case11|0 - local.get $2 - global.get $assembly/arguments/Arguments.ThreeReg - i32.eq - br_if $case12|0 - br $case13|0 - end - i32.const 0 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - call $assembly/program-build/immBytes - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:low - i32.const 1 - i32.add - local.set $split - i32.const 1 - local.get $split - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - local.get $split - i32.const 1 - i32.add - i32.const 255 - i32.and - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - call $assembly/program-build/immBytes - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 9 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n|5 - i32.store offset=8 - local.get $n|5 - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:hig - i32.const 1 - i32.add - local.set $split|6 - i32.const 1 - local.get $split|6 - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - local.get $split|6 - i32.const 255 - i32.and - i32.add - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n|7 - i32.store offset=12 - local.get $n|7 - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:hig - i32.const 1 - i32.add - local.set $split|8 - i32.const 1 - local.get $split|8 - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - local.get $split|8 - i32.const 255 - i32.and - i32.add - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - block $~lib/math/NativeMath.min|inlined.5 (result f64) - f64.const 4 - local.set $value1 - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.5 - end - i32.trunc_sat_f64_s - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - block $~lib/math/NativeMath.min|inlined.6 (result f64) - f64.const 4 - local.set $value1|11 - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - local.set $value2|12 - local.get $value1|11 - local.get $value2|12 - f64.min - br $~lib/math/NativeMath.min|inlined.6 - end - i32.trunc_sat_f64_s - i32.add - local.set $15 + i32.store offset=8 + local.get $key + call $~lib/util/hash/HASH + local.set $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $key + local.get $hashCode + call $"~lib/map/Map#find" + local.set $entry + local.get $entry + if + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.eq + if + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCapacity" + i32.const 3 + i32.mul + i32.const 4 + i32.div_s + i32.lt_s + if (result i32) + local.get $this + local.set $8 global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + else + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.const 1 + i32.shl + i32.const 1 + i32.or end + call $"~lib/map/Map#rehash" + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.tee $entries + i32.store offset=8 + local.get $entries + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.tee $6 + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesOffset" + local.get $6 + block $"~lib/map/ENTRY_SIZE|inlined.5" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.5" + end + i32.mul + i32.add + local.set $entry + local.get $entry + local.get $key + call $"~lib/map/MapEntry#set:key" + i32.const 0 + drop + local.get $entry + local.get $value + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/MapEntry#set:value" + i32.const 1 + drop + local.get $this + local.get $value + i32.const 1 + call $~lib/rt/itcms/__link + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#get:entriesCount" + i32.const 1 + i32.add + call $"~lib/map/Map#set:entriesCount" + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:buckets" + local.get $hashCode + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:bucketsMask" + i32.and + i32.const 4 + i32.mul + i32.add + local.set $bucketPtrBase + local.get $entry + local.get $bucketPtrBase + i32.load + call $"~lib/map/MapEntry#set:taggedNext" + local.get $bucketPtrBase + local.get $entry + i32.store + end + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/gas-costs/BlockGasCost#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 54 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/gas-costs/BlockGasCost#set:pc + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/gas-costs/BlockGasCost#set:gas + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $assembly/gas-costs/computeGasCosts (param $p i32) (result i32) + (local $len i32) + (local $blocks i32) + (local $currentBlock i32) + (local $i i32) + (local $instruction i32) + (local $iData i32) + (local $skipBytes i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + local.get $p + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/program/Program#get:code + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/typedarray/Uint8Array#get:length + local.set $len + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $"~lib/map/Map#constructor" + local.tee $blocks + i32.store offset=8 + i32.const 0 + local.set $currentBlock + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $len + i32.lt_s + if + local.get $p + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/program/Program#get:mask + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $15 + local.get $8 i32.store - local.get $15 - i32.const 1 + local.get $8 + local.get $i + call $assembly/program/Mask#isInstruction + i32.eqz + if + i32.const 14512 + i32.const 19072 + i32.const 16 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + local.get $p + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/program/Program#get:code + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n|13 - i32.store offset=16 - local.get $n|13 - local.set $15 + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $15 + local.get $8 i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:low - i32.const 1 - i32.add - local.set $split|14 - i32.const 2 - local.get $split|14 + local.get $8 + call $~lib/array/Array#get:length i32.const 255 i32.and - i32.add - local.get $data - local.set $15 + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $instruction + call $~lib/array/Array#__get + end + local.set $iData + local.get $p + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $15 + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/program/Program#get:basicBlocks + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 2 - local.get $split|14 - i32.const 255 - i32.and - i32.add - call $assembly/program-build/immBytes - i32.add - local.set $15 + local.get $8 + local.get $i + call $assembly/program/BasicBlocks#isStart + if + local.get $currentBlock + i32.const 0 + i32.ne + if + local.get $blocks + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $currentBlock + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $assembly/gas-costs/BlockGasCost#get:pc + local.get $currentBlock + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#set" + drop + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/gas-costs/BlockGasCost#constructor + local.tee $currentBlock + i32.store offset=16 + local.get $currentBlock + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + call $assembly/gas-costs/BlockGasCost#set:pc + end + local.get $currentBlock + i32.const 0 + i32.ne + if + local.get $currentBlock + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $currentBlock + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/gas-costs/BlockGasCost#get:gas + local.get $iData + call $assembly/instructions/Instruction#get:gas + i64.add + call $assembly/gas-costs/BlockGasCost#set:gas + end + local.get $p + local.set $8 global.get $~lib/memory/__stack_pointer - i32.const 24 + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/program/Program#get:mask + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $i + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipBytes + local.get $i + local.get $skipBytes i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return + local.set $i + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 end - i32.const 2 - local.set $15 + end + local.get $currentBlock + i32.const 0 + i32.ne + if + local.get $blocks + local.set $8 global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return + local.get $8 + i32.store + local.get $8 + local.get $currentBlock + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + call $assembly/gas-costs/BlockGasCost#get:pc + local.get $currentBlock + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $"~lib/map/Map#set" + drop end - i32.const 18528 - local.set $15 + local.get $blocks + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $bufferSize i32) + (local $buffer i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 55 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:length_ + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8128 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + local.tee $2 + i32.const 8 + local.tee $3 + local.get $2 + local.get $3 + i32.gt_u + select + i32.const 2 + i32.shl + local.set $bufferSize global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString - local.set $15 + local.get $bufferSize + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $6 global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store offset=20 - local.get $15 - call $~lib/string/String#concat - i32.const 19344 - i32.const 73 - i32.const 7 - call $~lib/builtins/abort - unreachable + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $bufferSize + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $length + call $~lib/array/Array#set:length_ + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 4 @@ -40185,280 +40714,756 @@ local.get $3 i32.store local.get $3 - call $~lib/staticarray/StaticArray#get:length + call $~lib/array/Array#get:length_ i32.ge_u if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ end local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:dataStart local.get $index - i32.const 0 + i32.const 2 i32.shl i32.add - i32.load8_u - local.set $value - i32.const 0 + local.get $value + i32.store + i32.const 1 drop + local.get $this local.get $value - local.set $3 + i32.const 1 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 - return ) - (func $assembly/program-build/buildMask (param $bytecode i32) (result i32) - (local $mask i32) + (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.get $newLength + i32.const 2 + i32.const 0 + call $~lib/array/ensureCapacity + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + local.get $newLength + call $~lib/array/Array#set:length_ + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#values" (param $this i32) (result i32) + (local $start i32) + (local $size i32) + (local $values i32) + (local $length i32) (local $i i32) - (local $instruction i32) - (local $iData i32) - (local $requiredBytes i32) + (local $entry i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.set $start + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.set $size + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $size + call $~lib/array/Array#constructor + local.tee $values + i32.store offset=4 + i32.const 0 + local.set $length + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $size + i32.lt_s + if + local.get $start + local.get $i + block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.6" + end + i32.mul + i32.add + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + local.tee $7 + i32.const 1 + i32.add + local.set $length + local.get $7 + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $~lib/array/Array#__set + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + call $~lib/array/Array#set:length + local.get $values + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $assembly/api-utils/getGasCosts (param $input i32) (param $kind i32) (param $withMetadata i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) (local $6 i32) - (local $packed i32) - (local $i|8 i32) - (local $byte i32) - (local $j i32) + (local $program i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $kind + local.get $withMetadata + local.get $input + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 0 + i32.const 3 + i32.const 56 + i32.const 18832 + call $~lib/rt/__newArray + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 18864 + call $~lib/rt/__newArray + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + i32.const 0 + i32.const 2 + i32.const 51 + i32.const 18896 + call $~lib/rt/__newArray + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $8 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 18928 + call $~lib/rt/__newArray + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $8 + call $assembly/api-utils/prepareProgram + local.tee $program + i32.store offset=20 + local.get $program + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $8 + call $assembly/spi/StandardProgram#get:program + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + call $assembly/gas-costs/computeGasCosts + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#values" + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + return + ) + (func $~lib/string/String#padStart (param $this i32) (param $length i32) (param $pad i32) (result i32) + (local $thisSize i32) + (local $targetSize i32) + (local $padSize i32) + (local $prependSize i32) + (local $out i32) + (local $repeatCount i32) + (local $restBase i32) + (local $restSize i32) (local $11 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $thisSize + local.get $length + i32.const 1 + i32.shl + local.set $targetSize + local.get $pad + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + i32.const 1 + i32.shl + local.set $padSize + local.get $targetSize + local.get $thisSize + i32.lt_u + if (result i32) + i32.const 1 + else + local.get $padSize + i32.eqz + end + if + local.get $this + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $targetSize + local.get $thisSize + i32.sub + local.set $prependSize + global.get $~lib/memory/__stack_pointer + local.get $targetSize + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $prependSize + local.get $padSize + i32.gt_u + if + local.get $prependSize + i32.const 2 + i32.sub + local.get $padSize + i32.div_u + local.set $repeatCount + local.get $repeatCount + local.get $padSize + i32.mul + local.set $restBase + local.get $prependSize + local.get $restBase + i32.sub + local.set $restSize + local.get $out + local.get $pad + local.get $padSize + local.get $repeatCount + call $~lib/memory/memory.repeat + local.get $out + local.get $restBase + i32.add + local.get $pad + local.get $restSize + memory.copy + else + local.get $out + local.get $pad + local.get $prependSize + memory.copy + end + local.get $out + local.get $prependSize + i32.add + local.get $this + local.get $thisSize + memory.copy + local.get $out + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + ) + (func $assembly/api-utils/disassemble~anonymous|0 (param $acc i32) (param $x i32) (param $$2 i32) (param $$3 i32) (result i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $acc + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $x + i32.const 16 + call $~lib/number/U8#toString + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + i32.const 2 + i32.const 15056 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $~lib/string/String#padStart + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $~lib/string/String.__concat + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/typedarray/Uint8Array#reduce<~lib/string/String> (param $this i32) (param $fn i32) (param $initialValue i32) (result i32) + (local $array i32) + (local $fn|4 i32) + (local $initialValue|5 i32) + (local $ptr i32) + (local $i i32) + (local $k i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - call $~lib/staticarray/StaticArray#constructor - local.tee $mask - i32.store offset=4 i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $bytecode - local.set $11 + i32.const 20 + memory.fill + block $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" (result i32) global.get $~lib/memory/__stack_pointer - local.get $11 + local.get $this + local.tee $array i32.store - local.get $11 + global.get $~lib/memory/__stack_pointer + local.get $fn + local.tee $fn|4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $initialValue + local.tee $initialValue|5 + i32.store offset=8 + local.get $array + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $~lib/arraybuffer/ArrayBufferView#get:dataStart + local.set $ptr + i32.const 0 + local.set $i + local.get $array + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 + local.set $k + loop $for-loop|0 local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/array/Array#get:length + local.get $k i32.lt_s - if (result i32) - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $instruction - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION - end - local.set $iData - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $i - i32.const 1 - call $~lib/staticarray/StaticArray#__set - global.get $assembly/arguments/REQUIRED_BYTES - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $iData - call $assembly/instructions/Instruction#get:kind - call $~lib/array/Array#__get - local.set $requiredBytes - local.get $i - i32.const 1 - i32.add - local.get $requiredBytes - i32.add - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - i32.le_s if + global.get $~lib/memory/__stack_pointer + local.get $initialValue|5 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + local.get $ptr local.get $i - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $bytecode - local.set $11 + i32.const 0 + i32.shl + i32.add + i32.load8_u + local.get $i + local.get $array + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $11 + local.get $9 + i32.store offset=16 + local.get $9 + i32.const 4 + global.set $~argumentsLength + local.get $fn|4 + i32.load + call_indirect (type $5) + local.tee $initialValue|5 i32.store offset=8 - local.get $11 local.get $i i32.const 1 i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $assembly/program-build/skipBytes - i32.add local.set $i + br $for-loop|0 end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 end + local.get $initialValue|5 + br $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" end + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + return + ) + (func $assembly/api-utils/disassemble (param $input i32) (param $kind i32) (param $withMetadata i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $program i32) + (local $output i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $kind + local.get $withMetadata + local.get $input + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 i32.const 0 - i32.const 27 - i32.const 19424 + i32.const 3 + i32.const 56 + i32.const 19136 call $~lib/rt/__newArray - local.tee $packed + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 19168 + call $~lib/rt/__newArray + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + i32.const 0 + i32.const 2 + i32.const 51 + i32.const 19200 + call $~lib/rt/__newArray + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 i32.store offset=12 + local.get $9 i32.const 0 - local.set $i|8 - loop $for-loop|1 - local.get $i|8 - local.get $mask - local.set $11 + i32.const 0 + i32.const 27 + i32.const 19232 + call $~lib/rt/__newArray + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + call $assembly/api-utils/prepareProgram + local.tee $program + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 14480 + local.tee $output + i32.store offset=24 + local.get $withMetadata + global.get $assembly/api-utils/HasMetadata.Yes + i32.eq + if global.get $~lib/memory/__stack_pointer - local.get $11 + i32.const 19264 + local.tee $output + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $output + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 i32.store - local.get $11 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - i32.const 0 - local.set $byte - local.get $i|8 - local.set $j - loop $for-loop|3 - local.get $j - local.get $i|8 - i32.const 8 - i32.add - i32.lt_s - if - local.get $byte - i32.const 255 - i32.and - i32.const 1 - i32.const 7 - i32.and - i32.shr_u - local.set $byte - local.get $j - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if (result i32) - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $j - call $~lib/staticarray/StaticArray#__get - else - i32.const 0 - end - if - local.get $byte - i32.const 128 - i32.or - local.set $byte - end - local.get $j - i32.const 1 - i32.add - local.set $j - br $for-loop|3 - end - end - local.get $packed - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $byte - call $~lib/array/Array#push - drop - local.get $i|8 - i32.const 8 - i32.add - local.set $i|8 - br $for-loop|1 - end + local.get $9 + i32.const 19312 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/string/String.__concat + local.tee $output + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $output + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $program + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=28 + local.get $9 + call $assembly/spi/StandardProgram#get:metadata + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + i32.const 19344 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + i32.const 14480 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $9 + call $~lib/typedarray/Uint8Array#reduce<~lib/string/String> + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/string/String.__concat + local.tee $output + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $output + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + i32.const 19376 + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/string/String.__concat + local.tee $output + i32.store offset=24 end - local.get $packed - local.set $11 global.get $~lib/memory/__stack_pointer - i32.const 16 + local.get $output + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $program + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $9 + call $assembly/spi/StandardProgram#get:program + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 + local.get $9 + call $assembly/api-internal/getAssembly + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/string/String.__concat + local.tee $output + i32.store offset=24 + local.get $output + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 32 i32.add global.set $~lib/memory/__stack_pointer - local.get $11 + local.get $9 return ) - (func $~lib/dataview/DataView#constructor (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) - (local $dataStart i32) - (local $5 i32) + (func $assembly/api-internal/VmInput#constructor (param $this i32) (param $program i32) (param $memory i32) (param $registers i32) (result i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub @@ -40474,570 +41479,555 @@ i32.eqz if global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 59 + i32.const 28 + i32.const 60 call $~lib/rt/itcms/__new local.tee $this i32.store end local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/dataview/DataView#set:buffer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/dataview/DataView#set:dataStart - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/dataview/DataView#set:byteLength - local.get $byteLength - i32.const 1073741820 - i32.gt_u - local.get $byteOffset - local.get $byteLength - i32.add - local.get $buffer - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/arraybuffer/ArrayBuffer#get:byteLength - i32.gt_u - i32.or - if - i32.const 8176 - i32.const 19456 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 - local.get $buffer - local.set $5 + local.get $4 + local.get $program + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=8 - local.get $5 - call $~lib/dataview/DataView#set:buffer - local.get $buffer - local.get $byteOffset - i32.add - local.set $dataStart - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $dataStart - call $~lib/dataview/DataView#set:dataStart + local.get $4 + call $assembly/api-internal/VmInput#set:program local.get $this - local.set $5 + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $4 i32.store offset=4 - local.get $5 - local.get $byteLength - call $~lib/dataview/DataView#set:byteLength - local.get $this - local.set $5 + local.get $4 + local.get $memory + local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $~lib/dataview/DataView#constructor@varargs (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) - (local $4 i32) + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/api-internal/VmInput#set:memory + local.get $this + local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check + local.get $4 + i32.store offset=4 + local.get $4 + local.get $registers + local.set $4 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $byteOffset - end - local.get $buffer - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/arraybuffer/ArrayBuffer#get:byteLength - local.set $byteLength - end + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/api-internal/VmInput#set:registers local.get $this local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store + i32.store offset=4 local.get $4 - local.get $buffer + i32.const 0 + call $assembly/api-internal/VmInput#set:pc + local.get $this local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store offset=4 local.get $4 - local.get $byteOffset - local.get $byteLength - call $~lib/dataview/DataView#constructor + i64.const 0 + call $assembly/api-internal/VmInput#set:gas + local.get $this local.set $4 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer local.get $4 ) - (func $~lib/dataview/DataView#setUint64 (param $this i32) (param $byteOffset i32) (param $value i64) (param $littleEndian i32) + (func $~lib/string/String#substring (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $len i32) (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $finalStart i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $finalEnd i32) + (local $14 i32) + (local $15 i32) + (local $fromPos i32) + (local $17 i32) + (local $18 i32) + (local $toPos i32) + (local $size i32) + (local $out i32) + (local $22 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $byteOffset - i32.const 31 - i32.shr_u - local.get $byteOffset - i32.const 8 - i32.add + i64.const 0 + i64.store local.get $this - local.set $4 + local.set $22 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $22 i32.store + local.get $22 + call $~lib/string/String#get:length + local.set $len + local.get $start + local.tee $4 + i32.const 0 + local.tee $5 local.get $4 - call $~lib/dataview/DataView#get:byteLength + local.get $5 i32.gt_s - i32.or + select + local.tee $6 + local.get $len + local.tee $7 + local.get $6 + local.get $7 + i32.lt_s + select + local.set $finalStart + local.get $end + local.tee $9 + i32.const 0 + local.tee $10 + local.get $9 + local.get $10 + i32.gt_s + select + local.tee $11 + local.get $len + local.tee $12 + local.get $11 + local.get $12 + i32.lt_s + select + local.set $finalEnd + local.get $finalStart + local.tee $14 + local.get $finalEnd + local.tee $15 + local.get $14 + local.get $15 + i32.lt_s + select + i32.const 1 + i32.shl + local.set $fromPos + local.get $finalStart + local.tee $17 + local.get $finalEnd + local.tee $18 + local.get $17 + local.get $18 + i32.gt_s + select + i32.const 1 + i32.shl + local.set $toPos + local.get $toPos + local.get $fromPos + i32.sub + local.set $size + local.get $size + i32.eqz if - i32.const 480 - i32.const 19456 - i32.const 174 - i32.const 7 - call $~lib/builtins/abort - unreachable + i32.const 14480 + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/dataview/DataView#get:dataStart - local.get $byteOffset - i32.add - local.get $littleEndian - if (result i64) - local.get $value + local.get $fromPos + i32.eqz + if (result i32) + local.get $toPos + local.get $len + i32.const 1 + i32.shl + i32.eq else - local.get $value - call $~lib/polyfills/bswap + i32.const 0 + end + if + local.get $this + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $22 + return end - i64.store global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $size + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $out + i32.store offset=4 + local.get $out + local.get $this + local.get $fromPos + i32.add + local.get $size + memory.copy + local.get $out + local.set $22 + global.get $~lib/memory/__stack_pointer + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer + local.get $22 + return ) - (func $assembly/codec/encodeVarU32 (param $v i64) (result i32) - (local $maxEncoded i64) - (local $dest i32) - (local $dataView i32) - (local $minEncoded i64) - (local $l i32) - (local $dest|6 i32) - (local $maxVal i32) - (local $byte i64) - (local $rest i64) + (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) + (local $lastIndex i32) + (local $value i64) + (local $sepLen i32) + (local $estLen i32) + (local $result i32) + (local $offset i32) + (local $value|9 i64) (local $i i32) (local $11 i32) global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - local.get $v i64.const 0 - i64.eq + i64.store + local.get $length + i32.const 1 + i32.sub + local.set $lastIndex + local.get $lastIndex + i32.const 0 + i32.lt_s if - i32.const 0 - i32.const 1 - call $~lib/typedarray/Uint8Array#constructor + i32.const 14480 local.set $11 global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer local.get $11 return end - i64.const 2 - i64.const 7 - i64.const 8 - i64.mul - call $~lib/math/ipow64 - local.set $maxEncoded - local.get $v - local.get $maxEncoded - i64.ge_u + local.get $lastIndex + i32.eqz if - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 9 - call $~lib/typedarray/Uint8Array#constructor - local.tee $dest - i32.store - local.get $dest - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - i32.const 255 - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $dest - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - i32.const 1 - global.set $~argumentsLength + local.get $dataStart + i64.load + local.set $value i32.const 0 - call $~lib/dataview/DataView#constructor@varargs - local.tee $dataView - i32.store offset=12 - local.get $dataView - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 1 - local.get $v - i32.const 1 - call $~lib/dataview/DataView#setUint64 - local.get $dest + drop + i32.const 8 + i32.const 4 + i32.le_u + drop + local.get $value + i32.const 10 + call $~lib/util/number/utoa64 local.set $11 global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer local.get $11 return end - local.get $maxEncoded - i64.const 7 - i64.shr_u - local.set $minEncoded - i32.const 7 - local.set $l + local.get $separator + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + call $~lib/string/String#get:length + local.set $sepLen + i32.const 20 + local.get $sepLen + i32.add + local.get $lastIndex + i32.mul + i32.const 20 + i32.add + local.set $estLen + global.get $~lib/memory/__stack_pointer + local.get $estLen + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $result + i32.store offset=4 + i32.const 0 + local.set $offset + i32.const 0 + local.set $i loop $for-loop|0 - local.get $l - i32.const 0 - i32.ge_s + local.get $i + local.get $lastIndex + i32.lt_s if - local.get $v - local.get $minEncoded - i64.ge_u + local.get $dataStart + local.get $i + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $sepLen if - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $l + local.get $result + local.get $offset i32.const 1 + i32.shl i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $dest|6 - i32.store offset=16 - i32.const 2 - i32.const 8 - local.get $l - i32.mul - call $~lib/math/ipow32 - local.set $maxVal - i32.const 2 - i32.const 8 - call $~lib/math/ipow32 - i32.const 2 - i32.const 8 - local.get $l - i32.sub - call $~lib/math/ipow32 - i32.sub - i64.extend_i32_s - local.get $v - local.get $maxVal - i64.extend_i32_s - i64.div_u - i64.add - local.set $byte - local.get $dest|6 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - local.get $byte - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - local.get $maxVal - i64.extend_i32_s - i64.rem_u - local.set $rest + local.get $separator + local.get $sepLen i32.const 1 - local.set $i - loop $for-loop|1 - local.get $i - i32.const 1 - local.get $l - i32.add - i32.lt_s - if - local.get $dest|6 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $i - local.get $rest - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $rest - i64.const 8 - i64.shr_u - local.set $rest - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|1 - end - end - local.get $dest|6 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.shl + memory.copy + local.get $offset + local.get $sepLen i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return + local.set $offset end - local.get $minEncoded - local.set $maxEncoded - local.get $minEncoded - i64.const 7 - i64.shr_u - local.set $minEncoded - local.get $l + local.get $i i32.const 1 - i32.sub - local.set $l + i32.add + local.set $i br $for-loop|0 end end - i32.const 19520 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $v - i32.const 10 - call $~lib/number/U64#toString + local.get $dataStart + local.get $lastIndex + i32.const 3 + i32.shl + i32.add + i64.load + local.set $value|9 + local.get $offset + local.get $result + local.get $offset + i32.const 1 + i32.shl + i32.add + local.get $value|9 + call $~lib/util/number/itoa_buffered + i32.add + local.set $offset + local.get $estLen + local.get $offset + i32.gt_s + if + local.get $result + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store + local.get $11 + i32.const 0 + local.get $offset + call $~lib/string/String#substring + local.set $11 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $11 + return + end + local.get $result local.set $11 global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/string/String#concat - i32.const 16384 - i32.const 160 - i32.const 3 - call $~lib/builtins/abort - unreachable + return ) - (func $assembly/program-build/wrapAsProgram (param $bytecode i32) (result i32) - (local $codeLength i32) - (local $mask i32) - (local $codeLengthBytes i32) - (local $data i32) - (local $offset i32) - (local $i i32) - (local $i|7 i32) - (local $i|8 i32) - (local $9 i32) + (func $~lib/staticarray/StaticArray#join (param $this i32) (param $separator i32) (result i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store i32.const 0 - i32.const 20 - memory.fill - local.get $bytecode - local.set $9 + drop + i32.const 1 + drop + local.get $this + local.get $this + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $2 + i32.store offset=4 + local.get $2 + call $~lib/staticarray/StaticArray#get:length + local.get $separator + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.set $codeLength + local.get $2 + call $~lib/util/string/joinIntegerArray + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $bytecode - local.set $9 + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $assembly/api-internal/executeProgram~anonymous|0 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - local.get $9 + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 19312 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store - local.get $9 - call $assembly/program-build/buildMask - local.tee $mask - i32.store offset=4 + local.get $3 + local.get $x + i32.const 16 + call $~lib/number/U64#toString + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $codeLength - i64.extend_i32_s - call $assembly/codec/encodeVarU32 - local.tee $codeLengthBytes - i32.store offset=8 + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/string/String#concat + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 1 + i32.const 8 i32.add - local.get $codeLengthBytes - local.set $9 + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $this i32) (param $fn i32) (result i32) + (local $len i32) + (local $out i32) + (local $outStart i32) + (local $i i32) + (local $result i32) + (local $7 i32) global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.add - local.get $codeLength - i32.add - local.get $mask - local.set $9 + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $data - i32.store offset=12 - local.get $data - local.set $9 + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 i32.const 0 - call $~lib/typedarray/Uint8Array#__set - local.get $data - local.set $9 + i32.store offset=8 + local.get $this + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $7 i32.store - local.get $9 - i32.const 1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set + local.get $7 + call $~lib/staticarray/StaticArray#get:length + local.set $len + global.get $~lib/memory/__stack_pointer + local.get $len i32.const 2 - local.set $offset + i32.const 61 + i32.const 0 + call $~lib/rt/__newArray + local.tee $out + i32.store offset=4 + local.get $out + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.set $outStart i32.const 0 local.set $i loop $for-loop|0 local.get $i - local.get $codeLengthBytes - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length + local.get $len i32.lt_s if - local.get $data - local.set $9 global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $offset - local.get $codeLengthBytes - local.set $9 + local.get $this + local.get $i + i32.const 3 + i32.shl + i32.add + i64.load + local.get $i + local.get $this + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 + local.get $7 + i32.store + local.get $7 + i32.const 3 + global.set $~argumentsLength + local.get $fn + i32.load + call_indirect (type $19) + local.tee $result + i32.store offset=8 + local.get $outStart local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $offset - i32.const 1 + i32.const 2 + i32.shl i32.add - local.set $offset + local.get $result + i32.store + i32.const 1 + drop + local.get $out + local.get $result + i32.const 1 + call $~lib/rt/itcms/__link local.get $i i32.const 1 i32.add @@ -41045,1127 +42035,1321 @@ br $for-loop|0 end end + local.get $out + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + ) + (func $~lib/array/Array<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) + (local $ptr i32) + (local $len i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $bytecode - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $offset - local.get $bytecode - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - local.get $i|7 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $offset - i32.const 1 - i32.add - local.set $offset - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end + i32.store + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array<~lib/string/String>#get:dataStart + local.set $ptr + local.get $this + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/array/Array<~lib/string/String>#get:length_ + local.set $len i32.const 0 - local.set $i|8 - loop $for-loop|2 - local.get $i|8 - local.get $mask - local.set $9 + drop + i32.const 0 + drop + i32.const 0 + drop + i32.const 0 + i32.const 1 + i32.lt_s + drop + i32.const 1 + drop + local.get $ptr + local.get $len + local.get $separator + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/util/string/joinStringArray + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $assembly/api-internal/executeProgram~anonymous|1 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + i32.const 19312 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $x + i32.const 16 + call $~lib/number/U64#toString + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/string/String#concat + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/program/ResolvedArguments#constructor (param $this i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + local.get $this + i32.eqz + if global.get $~lib/memory/__stack_pointer - local.get $9 + i32.const 36 + i32.const 63 + call $~lib/rt/itcms/__new + local.tee $this i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.lt_s - if - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $offset - local.get $mask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - local.get $i|8 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $offset - i32.const 1 - i32.add - local.set $offset - local.get $i|8 - i32.const 1 - i32.add - local.set $i|8 - br $for-loop|2 - end end - local.get $data - local.set $9 global.get $~lib/memory/__stack_pointer - i32.const 20 + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $~lib/object/Object#constructor + local.tee $this + i32.store + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:a + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:b + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:c + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + call $assembly/program/ResolvedArguments#set:d + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + call $assembly/arguments/Args#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/program/ResolvedArguments#set:decoded + local.get $this + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $9 - return + local.get $1 ) - (func $assembly/api/fillRegisters (param $registers i32) (param $flat i32) - (local $len i32) - (local $3 i32) - (local $4 i32) - (local $i i32) - (local $num i64) - (local $j i32) - (local $index i32) - (local $9 i32) + (func $assembly/program/resolveArguments (param $kind i32) (param $data i32) (param $lim i32) (param $registers i32) (result i32) + (local $args i32) + (local $resolved i32) + (local $6 i32) + (local $7 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $9 + i32.const 0 + i32.const 20 + memory.fill global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/staticarray/StaticArray#get:length - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - local.set $len - local.get $len - local.get $flat - local.set $9 + local.get $kind + local.get $data + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $7 i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.ne + local.get $7 + local.get $lim + call $assembly/program/decodeArguments + local.tee $args + i32.store offset=4 + local.get $args + i32.const 0 + i32.eq if + i32.const 0 + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $flat - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $len - i32.const 10 - call $~lib/number/I32#toString - local.tee $4 - i32.store offset=8 - i32.const 19744 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 1 - local.get $3 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 19744 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 3 - local.get $4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 19744 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 14400 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 19792 - i32.const 166 - i32.const 5 - call $~lib/builtins/abort - unreachable + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return end + global.get $~lib/memory/__stack_pointer i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - i64.const 0 - local.set $num - i32.const 0 - local.set $j - loop $for-loop|1 - local.get $j - global.get $assembly/registers/REG_SIZE_BYTES - i32.const 255 - i32.and - i32.lt_u - if - local.get $i - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - local.get $j - i32.add - local.set $index - local.get $num - local.get $flat - local.set $9 + call $assembly/program/ResolvedArguments#constructor + local.tee $resolved + i32.store offset=8 + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/program/ResolvedArguments#set:decoded + block $case13|0 + block $case12|0 + block $case11|0 + block $case10|0 + block $case9|0 + block $case8|0 + block $case7|0 + block $case6|0 + block $case5|0 + block $case4|0 + block $case3|0 + block $case2|0 + block $case1|0 + block $case0|0 + local.get $kind + local.set $6 + local.get $6 + global.get $assembly/arguments/Arguments.Zero + i32.eq + br_if $case0|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneImm + i32.eq + br_if $case1|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoImm + i32.eq + br_if $case2|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneOff + i32.eq + br_if $case3|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegOneImm + i32.eq + br_if $case4|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegOneExtImm + i32.eq + br_if $case5|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegTwoImm + i32.eq + br_if $case6|0 + local.get $6 + global.get $assembly/arguments/Arguments.OneRegOneImmOneOff + i32.eq + br_if $case7|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoReg + i32.eq + br_if $case8|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoRegOneImm + i32.eq + br_if $case9|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoRegOneOff + i32.eq + br_if $case10|0 + local.get $6 + global.get $assembly/arguments/Arguments.TwoRegTwoImm + i32.eq + br_if $case11|0 + local.get $6 + global.get $assembly/arguments/Arguments.ThreeReg + i32.eq + br_if $case12|0 + br $case13|0 + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + i64.const 32 + i64.shl + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + i64.add + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $7 i32.store - local.get $9 - local.get $index - call $~lib/array/Array#__get - i64.extend_i32_u - local.get $j - i32.const 8 - i32.mul - i32.const 255 - i32.and + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a i64.extend_i32_u - i64.shl - i64.or - local.set $num - local.get $j - i32.const 1 - i32.add - local.set $j - br $for-loop|1 - end - end - local.get $registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $i - local.get $num - call $~lib/staticarray/StaticArray#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/interpreter/Interpreter#constructor@varargs (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 2 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $assembly/memory/MemoryBuilder#build - local.tee $memory - i32.store offset=4 - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/interpreter/Interpreter#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/api/resetGeneric (param $program i32) (param $flatRegisters i32) (param $initialGas i64) - (local $p i32) - (local $registers i32) - (local $int i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $program - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - call $assembly/program/liftBytes - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $assembly/program/deblob - local.tee $p - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=12 - local.get $registers - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $flatRegisters - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - call $assembly/api/fillRegisters - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $p - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $registers - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 2 - global.set $~argumentsLength - i32.const 0 - call $assembly/interpreter/Interpreter#constructor@varargs - local.tee $int - i32.store offset=16 - local.get $int - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - call $assembly/interpreter/Interpreter#get:gas - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $initialGas - call $assembly/gas/GasCounter#set@override - local.get $int - global.set $assembly/api/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-generic/InitialPage#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 48 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/api-generic/InitialPage#set:address - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/api-generic/InitialPage#set:length - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/memory-page/Access.None - call $assembly/api-generic/InitialPage#set:access - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api/readPages (param $pageMap i32) (result i32) - (local $1 i32) - (local $pages i32) - (local $codec i32) - (local $p i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 19856 - call $~lib/rt/__newArray - local.tee $pages - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $pageMap - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $codec - i32.store offset=8 - loop $while-continue|0 - local.get $codec - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-generic/InitialPage#constructor - local.tee $p - i32.store offset=12 - local.get $p - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $codec - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/codec/Decoder#u32 - call $assembly/api-generic/InitialPage#set:address - local.get $p - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $codec - local.set $5 + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $resolved + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/codec/Decoder#u32 - call $assembly/api-generic/InitialPage#set:length - local.get $p - local.set $5 + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $codec - local.set $5 + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $7 i32.store offset=16 - local.get $5 - call $assembly/codec/Decoder#u8 - i32.const 0 - i32.gt_u - if (result i32) - global.get $assembly/memory-page/Access.Write - else - global.get $assembly/memory-page/Access.Read - end - call $assembly/api-generic/InitialPage#set:access - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $p - local.set $5 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $~lib/array/Array#push - drop - br $while-continue|0 - end - end - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/api/readChunks (param $chunks i32) (result i32) - (local $1 i32) - (local $res i32) - (local $codec i32) - (local $c i32) - (local $len i32) - (local $data i32) - (local $i i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 19888 - call $~lib/rt/__newArray - local.tee $res - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $chunks - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $codec - i32.store offset=8 - loop $while-continue|0 - local.get $codec - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-generic/InitialChunk#constructor - local.tee $c + local.get $7 i32.store offset=12 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $codec - local.set $8 + local.get $7 + local.get $args + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $8 + local.get $7 i32.store offset=16 - local.get $8 - call $assembly/codec/Decoder#u32 - call $assembly/api-generic/InitialChunk#set:address - local.get $codec - local.set $8 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/codec/Decoder#u32 - local.set $len + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $codec - local.set $8 + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:c + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $len - call $assembly/codec/Decoder#bytes - local.tee $data - i32.store offset=20 - i32.const 0 - local.set $i - loop $for-loop|1 - local.get $i - local.get $len - i32.lt_u - if - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $assembly/api-generic/InitialChunk#get:data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#push - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|1 - end - end - local.get $res - local.set $8 + local.get $7 + i32.store + local.get $7 + local.get $args + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $c - local.set $8 + local.get $7 + i32.store offset=12 + local.get $7 + call $assembly/arguments/Args#get:d + call $assembly/instructions/utils/u32SignExtend + call $assembly/program/ResolvedArguments#set:d + local.get $resolved + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/array/Array#push - drop - br $while-continue|0 + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return end + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:a + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:b + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + local.get $registers + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + local.get $args + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + call $assembly/program/ResolvedArguments#set:c + local.get $resolved + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return end - local.get $res - local.set $8 + i32.const 16864 + local.set $7 global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return + local.get $7 + i32.store + local.get $7 + local.get $kind + i32.const 10 + call $~lib/number/I32#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $7 + call $~lib/string/String#concat + i32.const 19936 + i32.const 332 + i32.const 7 + call $~lib/builtins/abort + unreachable ) - (func $assembly/api/resetGenericWithMemory (param $program i32) (param $flatRegisters i32) (param $pageMap i32) (param $chunks i32) (param $initialGas i64) - (local $p i32) - (local $registers i32) - (local $builder i32) - (local $memory i32) - (local $int i32) - (local $10 i32) + (func $assembly/api-internal/VmOutput#constructor (param $this i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 36 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $program - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $assembly/program/liftBytes - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/program/deblob - local.tee $p - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=12 - local.get $registers - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $flatRegisters - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $assembly/api/fillRegisters + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store offset=16 + i32.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 59 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $10 + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $10 + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/object/Object#constructor + local.tee $this i32.store - local.get $10 - local.get $pageMap - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=24 - local.get $10 - call $assembly/api/readPages - local.set $10 + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $10 + local.get $3 i32.store offset=4 - local.get $10 - local.get $chunks - local.set $10 + local.get $3 + global.get $assembly/interpreter/Status.OK + call $assembly/api-internal/VmOutput#set:status + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=24 - local.get $10 - call $assembly/api/readChunks - local.set $10 + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.const 3 + i32.const 56 + i32.const 20272 + call $~lib/rt/__newArray + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $10 - call $assembly/api-generic/buildMemory - local.tee $memory - i32.store offset=28 + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/api-internal/VmOutput#set:registers + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 i32.const 0 - local.get $p - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $registers - local.set $10 + call $assembly/api-internal/VmOutput#set:pc + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $10 + local.get $3 i32.store offset=4 - local.get $10 - local.get $memory - local.set $10 + local.get $3 + i32.const 0 + i32.const 2 + i32.const 51 + i32.const 20304 + call $~lib/rt/__newArray + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $10 - call $assembly/interpreter/Interpreter#constructor - local.tee $int - i32.store offset=32 - local.get $int - local.set $10 + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/api-internal/VmOutput#set:memory + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $10 + local.get $3 i32.store offset=4 - local.get $10 - call $assembly/interpreter/Interpreter#get:gas - local.set $10 + local.get $3 + i64.const 0 + call $assembly/api-internal/VmOutput#set:gas + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $initialGas - call $assembly/gas/GasCounter#set@override - local.get $int - global.set $assembly/api/interpreter + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + call $assembly/api-internal/VmOutput#set:exitCode + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 36 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer + local.get $3 ) - (func $assembly/api/nextStep (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) + (func $~lib/staticarray/StaticArray#slice<~lib/array/Array> (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $length i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $sourceStart i32) + (local $size i32) + (local $out i32) + (local $outStart i32) + (local $18 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + local.get $this + local.set $18 global.get $~lib/memory/__stack_pointer + local.get $18 + i32.store + local.get $18 + call $~lib/staticarray/StaticArray#get:length + local.set $length + local.get $start i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter + i32.lt_s + if (result i32) + local.get $start + local.get $length + i32.add + local.tee $4 + i32.const 0 + local.tee $5 + local.get $4 + local.get $5 + i32.gt_s + select + else + local.get $start + local.tee $6 + local.get $length + local.tee $7 + local.get $6 + local.get $7 + i32.lt_s + select + end + local.set $start + local.get $end i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 19792 - i32.const 43 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/interpreter/Interpreter#nextStep - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.lt_s + if (result i32) + local.get $end + local.get $length i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return + local.tee $8 + i32.const 0 + local.tee $9 + local.get $8 + local.get $9 + i32.gt_s + select + else + local.get $end + local.tee $10 + local.get $length + local.tee $11 + local.get $10 + local.get $11 + i32.lt_s + select end + local.set $end + local.get $end + local.get $start + i32.sub + local.tee $12 i32.const 0 - local.set $2 + local.tee $13 + local.get $12 + local.get $13 + i32.gt_s + select + local.set $length + local.get $this + local.get $start + i32.const 3 + i32.shl + i32.add + local.set $sourceStart + local.get $length + i32.const 3 + i32.shl + local.set $size global.get $~lib/memory/__stack_pointer - i32.const 12 + local.get $this + local.tee $out + i32.store offset=4 + i32.const 1 + drop + global.get $~lib/memory/__stack_pointer + local.get $length + i32.const 3 + i32.const 56 + i32.const 0 + call $~lib/rt/__newArray + local.tee $out + i32.store offset=4 + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + local.get $18 + i32.store + local.get $18 + call $~lib/array/Array#get:dataStart + local.set $outStart + i32.const 0 + drop + local.get $outStart + local.get $sourceStart + local.get $size + memory.copy + local.get $out + local.set $18 + global.get $~lib/memory/__stack_pointer + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $18 return ) - (func $assembly/api/nSteps (param $steps i32) (result i32) - (local $1 i32) - (local $int i32) - (local $isOk i32) - (local $i i32) - (local $5 i32) + (func $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs (param $this i32) (param $start i32) (param $end i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 51 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - i32.const 1 - local.set $isOk - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $steps - i32.lt_u - if - local.get $int - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/interpreter/Interpreter#nextStep - local.set $isOk - local.get $isOk - i32.eqz - if - i32.const 0 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return + i32.store + block $2of2 + block $1of2 + block $0of2 + block $outOfRange + global.get $~argumentsLength + br_table $0of2 $1of2 $2of2 $outOfRange end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 + unreachable end + i32.const 0 + local.set $start end - local.get $isOk - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return + global.get $~lib/builtins/i32.MAX_VALUE + local.set $end end - i32.const 0 - local.set $5 + local.get $this + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 12 + local.get $3 + i32.store + local.get $3 + local.get $start + local.get $end + call $~lib/staticarray/StaticArray#slice<~lib/array/Array> + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $5 - return + local.get $3 ) - (func $assembly/api/getProgramCounter (result i32) - (local $0 i32) - (local $int i32) + (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) (local $2 i32) + (local $3 i32) + (local $bufferSize i32) + (local $buffer i32) + (local $6 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check @@ -42173,665 +43357,1775 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $this + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 38 + call $~lib/rt/itcms/__new + local.tee $this + i32.store + end + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 i32.const 0 - i32.eq + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i32.const 0 + call $~lib/array/Array#set:length_ + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u if - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return + i32.const 8176 + i32.const 8128 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable end + local.get $length + local.tee $2 + i32.const 8 + local.tee $3 + local.get $2 + local.get $3 + i32.gt_u + select + i32.const 2 + i32.shl + local.set $bufferSize + global.get $~lib/memory/__stack_pointer + local.get $bufferSize + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $buffer + i32.store offset=8 + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $~lib/array/Array#set:buffer + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $buffer + call $~lib/array/Array#set:dataStart + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $bufferSize + call $~lib/array/Array#set:byteLength + local.get $this + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + local.get $length + call $~lib/array/Array#set:length_ + local.get $this + local.set $6 global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 19792 - i32.const 68 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int + local.get $this + local.get $newLength + i32.const 2 + i32.const 0 + call $~lib/array/ensureCapacity + local.get $this local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=8 + i32.store local.get $2 - call $assembly/interpreter/Interpreter#get:pc - local.set $2 + local.get $newLength + call $~lib/array/Array#set:length_ global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 - return ) - (func $assembly/api/setNextProgramCounter (param $pc i32) - (local $1 i32) - (local $int i32) - (local $3 i32) + (func $"~lib/map/Map#keys" (param $this i32) (result i32) + (local $start i32) + (local $size i32) + (local $keys i32) + (local $length i32) + (local $i i32) + (local $entry i32) + (local $7 i32) + (local $8 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i64.const 0 i64.store + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entries" + local.set $start + local.get $this + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $"~lib/map/Map#get:entriesOffset" + local.set $size global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter + local.get $size + call $~lib/array/Array#constructor + local.tee $keys + i32.store offset=4 i32.const 0 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return + local.set $length + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $size + i32.lt_s + if + local.get $start + local.get $i + block $"~lib/map/ENTRY_SIZE|inlined.8" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.8" + end + i32.mul + i32.add + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz + if + local.get $keys + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $length + local.tee $7 + i32.const 1 + i32.add + local.set $length + local.get $7 + local.get $entry + call $"~lib/map/MapEntry#get:key" + call $~lib/array/Array#__set + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end end + local.get $keys + local.set $8 global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 + local.get $8 i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 76 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $pc - call $assembly/interpreter/Interpreter#set:nextPc + local.get $8 + local.get $length + call $~lib/array/Array#set:length + local.get $keys + local.set $8 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer + local.get $8 + return ) - (func $assembly/api/getStatus (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) + (func $~lib/array/Array#get:length (param $this i32) (result i32) + (local $1 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter i32.const 0 - i32.eq - if - global.get $assembly/interpreter/Status.PANIC - i32.const 255 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 19792 - i32.const 84 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 + local.get $this + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/interpreter/Interpreter#get:status - i32.const 255 - i32.and - local.set $2 + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length_ + local.set $1 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $1 return ) - (func $assembly/api/getExitArg (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) + (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.const 0 - i32.eq + i32.store + local.get $index + local.get $this + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length_ + i32.ge_u if + local.get $index + i32.const 0 + i32.lt_s + if + i32.const 480 + i32.const 8128 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $this + local.get $index + i32.const 1 + i32.add i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer local.get $3 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 19792 - i32.const 92 - i32.const 28 - call $~lib/builtins/abort - unreachable + i32.store + local.get $3 + local.get $index + i32.const 1 + i32.add + call $~lib/array/Array#set:length_ end - local.tee $int - i32.store offset=4 - local.get $int + local.get $this local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=8 + i32.store local.get $3 - call $assembly/interpreter/Interpreter#get:exitCode - local.tee $2 - if (result i32) - local.get $2 - else - i32.const 0 - end - local.set $3 + call $~lib/array/Array#get:dataStart + local.get $index + i32.const 0 + i32.shl + i32.add + local.get $value + i32.store8 + i32.const 0 + drop global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 - return ) - (func $assembly/api/getGasLeft (result i64) - (local $0 i32) - (local $int i32) - (local $2 i32) - (local $3 i64) + (func $assembly/api-internal/getOutputChunks (param $memory i32) (result i32) + (local $1 i32) + (local $chunks i32) + (local $pages i32) + (local $currentChunk i32) + (local $i i32) + (local $pageIdx i32) + (local $page i32) + (local $n i32) + (local $v i32) + (local $10 i32) + (local $11 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 32 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + i32.const 0 + i32.const 32 + memory.fill global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter i32.const 0 - i32.eq - if - i64.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end + i32.const 2 + i32.const 51 + i32.const 20336 + call $~lib/rt/__newArray + local.tee $chunks + i32.store global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $11 global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 19792 - i32.const 100 - i32.const 28 - call $~lib/builtins/abort - unreachable + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory/Memory#get:pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $"~lib/map/Map#keys" + local.tee $pages + i32.store offset=12 + i32.const 0 + local.set $currentChunk + i32.const 0 + local.set $i + loop $for-loop|0 + local.get $i + local.get $pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/array/Array#get:length + i32.lt_s + if + block $for-continue|0 + local.get $pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $i + call $~lib/array/Array#__get + local.set $pageIdx + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory/Memory#get:pages + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $pageIdx + call $"~lib/map/Map#get" + local.tee $page + i32.store offset=16 + local.get $page + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory-page/Page#get:raw + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $assembly/memory-page/RawPage#get:page + i32.const 0 + i32.eq + if + br $for-continue|0 + end + i32.const 0 + local.set $n + loop $for-loop|1 + local.get $n + local.get $page + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=20 + local.get $11 + call $assembly/memory-page/Page#get:raw + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory-page/RawPage#get:data + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $page + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=20 + local.get $11 + call $assembly/memory-page/Page#get:raw + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/memory-page/RawPage#get:data + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $n + call $~lib/typedarray/Uint8Array#__get + local.set $v + local.get $v + i32.const 0 + i32.ne + if + local.get $currentChunk + i32.const 0 + i32.ne + if + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/api-internal/InitialChunk#get:data + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $v + call $~lib/array/Array#push + drop + else + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/api-internal/InitialChunk#constructor + local.tee $currentChunk + i32.store offset=24 + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $pageIdx + global.get $assembly/memory-page/PAGE_SIZE + i32.mul + local.get $n + i32.add + call $assembly/api-internal/InitialChunk#set:address + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + global.get $~lib/memory/__stack_pointer + i32.const 1 + i32.const 0 + i32.const 27 + i32.const 0 + call $~lib/rt/__newArray + local.tee $10 + i32.store offset=28 + local.get $10 + i32.const 0 + local.get $v + call $~lib/array/Array#__set + local.get $10 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $assembly/api-internal/InitialChunk#set:data + end + else + local.get $currentChunk + i32.const 0 + i32.ne + if + local.get $chunks + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + local.get $currentChunk + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + local.get $11 + call $~lib/array/Array#push + drop + i32.const 0 + local.set $currentChunk + end + end + local.get $n + i32.const 1 + i32.add + local.set $n + br $for-loop|1 + end + end + end + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - call $assembly/interpreter/Interpreter#get:gas - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/gas/GasCounter#get@override - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/api/setGasLeft (param $gas i64) - (local $1 i32) - (local $int i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter + local.get $currentChunk i32.const 0 i32.ne if + local.get $chunks + local.set $11 global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 106 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.tee $int + local.get $11 i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/interpreter/Interpreter#get:gas - local.set $3 + local.get $11 + local.get $currentChunk + local.set $11 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $11 i32.store offset=8 - local.get $3 - local.get $gas - call $assembly/gas/GasCounter#set@override + local.get $11 + call $~lib/array/Array#push + drop end + local.get $chunks + local.set $11 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 32 i32.add global.set $~lib/memory/__stack_pointer + local.get $11 + return ) - (func $assembly/api/getRegisters (result i32) - (local $flat i32) - (local $1 i32) - (local $int i32) - (local $i i32) - (local $val i64) - (local $j i32) - (local $index i32) - (local $7 i32) + (func $assembly/api-internal/executeProgram (param $int i32) (param $logs i32) (result i32) + (local $isOk i32) + (local $3 i32) + (local $4 i32) + (local $instruction i32) + (local $iData i32) + (local $skipBytes i32) + (local $name i32) + (local $9 i32) + (local $10 i32) + (local $args i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + (local $17 i32) + (local $18 i32) + (local $19 i32) + (local $20 i32) + (local $21 i32) + (local $22 i32) + (local $23 i32) + (local $output i32) + (local $25 i32) global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 108 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 20 + i32.const 108 memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - call $~lib/typedarray/Uint8Array#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - i32.const 0 - i32.const 0 i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.tee $flat - i32.store offset=4 - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - local.get $flat - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store offset=8 - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 117 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=12 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $int - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/interpreter/Interpreter#get:registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - local.get $int - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/interpreter/Interpreter#get:registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $i - call $~lib/staticarray/StaticArray#__get - local.set $val - i32.const 0 - local.set $j - loop $for-loop|1 - local.get $j - global.get $assembly/registers/REG_SIZE_BYTES - i32.lt_s + local.set $isOk + block $for-break0 + loop $for-loop|0 + i32.const 1 + if + local.get $isOk + i32.eqz if - local.get $i - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - local.get $j - i32.add - local.set $index - local.get $flat - local.set $7 + local.get $logs + if + global.get $~lib/memory/__stack_pointer + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + call $assembly/interpreter/Interpreter#get:registers + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 16800 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray#join + local.tee $3 + i32.store offset=16 + i32.const 19504 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 1 + local.get $3 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 19504 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 14480 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + end + local.get $logs + if + global.get $~lib/memory/__stack_pointer + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=24 + local.get $25 + call $assembly/interpreter/Interpreter#get:registers + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + i32.const 19568 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=20 + local.get $25 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 16800 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/array/Array<~lib/string/String>#join + local.tee $4 + i32.store offset=28 + i32.const 19536 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 1 + local.get $4 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 19536 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 14480 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 19600 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + call $assembly/interpreter/Interpreter#get:status + i32.const 10 + call $~lib/number/I32#toString + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/string/String#concat + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + end + br $for-break0 + end + local.get $logs + if + i32.const 19664 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + call $assembly/interpreter/Interpreter#get:pc + i32.const 10 + call $~lib/number/U32#toString + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/string/String#concat + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 19696 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=20 + local.get $25 + call $assembly/interpreter/Interpreter#get:gas + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + call $assembly/gas/GasCounter#get@override + i32.const 10 + call $~lib/number/I64#toString + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/string/String#concat + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 19728 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + call $assembly/interpreter/Interpreter#get:status + i32.const 10 + call $~lib/number/I32#toString + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/string/String#concat + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 19408 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=24 + local.get $25 + call $assembly/interpreter/Interpreter#get:registers + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + i32.const 16800 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=20 + local.get $25 + call $~lib/staticarray/StaticArray#join + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/string/String#concat + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + end + local.get $logs + if + i32.const 19408 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=36 + local.get $25 + call $assembly/interpreter/Interpreter#get:registers + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=24 + local.get $25 + i32.const 19776 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=32 + local.get $25 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + i32.const 16800 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=20 + local.get $25 + call $~lib/array/Array<~lib/string/String>#join + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/string/String#concat + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + end + local.get $logs + if + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $assembly/interpreter/Interpreter#get:pc + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $assembly/interpreter/Interpreter#get:program + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/Program#get:code + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_u + if (result i32) + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $assembly/interpreter/Interpreter#get:program + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/Program#get:code + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/interpreter/Interpreter#get:pc + call $~lib/typedarray/Uint8Array#__get + else + i32.const 0 + end + local.set $instruction + local.get $instruction + global.get $assembly/instructions/INSTRUCTIONS + local.set $25 global.get $~lib/memory/__stack_pointer - local.get $7 + local.get $25 i32.store - local.get $7 - local.get $index - local.get $val - i64.const 255 - i64.and - i32.wrap_i64 + local.get $25 + call $~lib/array/Array#get:length i32.const 255 i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $val - i64.const 8 - i64.shr_u - local.set $val - local.get $j + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $assembly/instructions/INSTRUCTIONS + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + local.get $instruction + call $~lib/array/Array#__get + end + local.set $iData + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $assembly/interpreter/Interpreter#get:program + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/Program#get:mask + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/interpreter/Interpreter#get:pc + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $skipBytes + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:namePtr + local.tee $name + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $name + local.tee $9 + i32.store offset=44 + global.get $~lib/memory/__stack_pointer + local.get $instruction + i32.const 10 + call $~lib/number/U8#toString + local.tee $10 + i32.store offset=48 + i32.const 19888 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 1 + local.get $9 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 19888 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 3 + local.get $10 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 19888 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 14480 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer + local.get $iData + call $assembly/instructions/Instruction#get:kind + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=20 + local.get $25 + call $assembly/interpreter/Interpreter#get:program + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + call $assembly/program/Program#get:code + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + call $assembly/interpreter/Interpreter#get:pc i32.const 1 i32.add - local.set $j - br $for-loop|1 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + local.get $skipBytes + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $assembly/interpreter/Interpreter#get:registers + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/resolveArguments + local.tee $args + i32.store offset=52 + local.get $args + i32.const 0 + i32.ne + if + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/ResolvedArguments#get:a + i32.const 10 + call $~lib/number/I64#toString + local.tee $12 + i32.store offset=56 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $assembly/program/ResolvedArguments#get:decoded + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/arguments/Args#get:a + i32.const 10 + call $~lib/number/U32#toString + local.tee $13 + i32.store offset=60 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/ResolvedArguments#get:a + i32.const 16 + call $~lib/number/U64#toString + local.tee $14 + i32.store offset=64 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/ResolvedArguments#get:b + i32.const 10 + call $~lib/number/I64#toString + local.tee $15 + i32.store offset=68 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $assembly/program/ResolvedArguments#get:decoded + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/arguments/Args#get:b + i32.const 10 + call $~lib/number/U32#toString + local.tee $16 + i32.store offset=72 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/ResolvedArguments#get:b + i32.const 16 + call $~lib/number/U64#toString + local.tee $17 + i32.store offset=76 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/ResolvedArguments#get:c + i32.const 10 + call $~lib/number/I64#toString + local.tee $18 + i32.store offset=80 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $assembly/program/ResolvedArguments#get:decoded + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/arguments/Args#get:c + i32.const 10 + call $~lib/number/U32#toString + local.tee $19 + i32.store offset=84 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/ResolvedArguments#get:c + i32.const 16 + call $~lib/number/U64#toString + local.tee $20 + i32.store offset=88 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/ResolvedArguments#get:d + i32.const 10 + call $~lib/number/I64#toString + local.tee $21 + i32.store offset=92 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $assembly/program/ResolvedArguments#get:decoded + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/arguments/Args#get:d + i32.const 10 + call $~lib/number/U32#toString + local.tee $22 + i32.store offset=96 + global.get $~lib/memory/__stack_pointer + local.get $args + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/program/ResolvedArguments#get:d + i32.const 16 + call $~lib/number/U64#toString + local.tee $23 + i32.store offset=100 + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 1 + local.get $12 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 3 + local.get $13 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 5 + local.get $14 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 7 + local.get $15 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 9 + local.get $16 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 11 + local.get $17 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 13 + local.get $18 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 15 + local.get $19 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 17 + local.get $20 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 19 + local.get $21 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 21 + local.get $22 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 23 + local.get $23 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 20144 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + i32.const 14480 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + end end + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $assembly/interpreter/Interpreter#nextStep + local.set $isOk + br $for-loop|0 end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 end end - local.get $flat - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $assembly/api/setRegisters (param $flatRegisters i32) - (local $1 i32) - (local $int i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 20 - memory.fill - global.get $assembly/api/interpreter - i32.const 0 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer + call $assembly/api-internal/VmOutput#constructor + local.tee $output + i32.store offset=104 + local.get $output + local.set $25 global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 + local.get $25 i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 134 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 + local.get $25 local.get $int - local.set $3 + local.set $25 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $3 - call $assembly/interpreter/Interpreter#get:registers - local.set $3 + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/interpreter/Interpreter#get:status + call $assembly/api-internal/VmOutput#set:status + local.get $output + local.set $25 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $flatRegisters - local.set $3 + local.get $25 + i32.store + local.get $25 + local.get $int + local.set $25 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $25 i32.store offset=12 - local.get $3 - call $assembly/api/fillRegisters + local.get $25 + call $assembly/interpreter/Interpreter#get:registers + local.set $25 global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#pageDump (param $this i32) (param $index i32) (result i32) - (local $2 i32) + local.get $25 + i32.store offset=8 + local.get $25 + i32.const 0 + i32.const 1 + global.set $~argumentsLength + i32.const 0 + call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs + local.set $25 global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/api-internal/VmOutput#set:registers + local.get $output + local.set $25 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + local.get $25 + i32.store + local.get $25 + local.get $int + local.set $25 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/interpreter/Interpreter#get:pc + call $assembly/api-internal/VmOutput#set:pc + local.get $output + local.set $25 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $25 + i32.store + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $assembly/interpreter/Interpreter#get:gas + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 i32.store offset=4 - local.get $2 - call $assembly/memory/Memory#get:pages - local.set $2 + local.get $25 + call $assembly/gas/GasCounter#get@override + call $assembly/api-internal/VmOutput#set:gas + local.get $output + local.set $25 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $25 i32.store - local.get $2 - local.get $index - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - local.get $this - local.set $2 + local.get $25 + local.get $int + local.set $25 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $25 i32.store offset=12 - local.get $2 - call $assembly/memory/Memory#get:pages - local.set $2 + local.get $25 + call $assembly/interpreter/Interpreter#get:memory + local.set $25 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $25 i32.store offset=8 - local.get $2 - local.get $index - call $"~lib/map/Map#get" - local.set $2 + local.get $25 + call $assembly/api-internal/getOutputChunks + local.set $25 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $25 i32.store offset=4 - local.get $2 - call $assembly/memory-page/Page#get:raw - local.set $2 + local.get $25 + call $assembly/api-internal/VmOutput#set:memory + local.get $output + local.set $25 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $25 i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:data - local.set $2 + local.get $25 + local.get $int + local.set $25 global.get $~lib/memory/__stack_pointer - i32.const 16 + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/interpreter/Interpreter#get:exitCode + call $assembly/api-internal/VmOutput#set:exitCode + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + call $assembly/interpreter/Interpreter#get:memory + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $assembly/memory/Memory#free + local.get $output + local.set $25 + global.get $~lib/memory/__stack_pointer + i32.const 108 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $25 return ) - (func $assembly/api/getPageDump (param $index i32) (result i32) - (local $1 i32) + (func $assembly/api-internal/runVm (param $input i32) (param $logs i32) (param $useSbrkGas i32) (result i32) (local $int i32) - (local $page i32) (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 20 @@ -42842,94 +45136,97 @@ i32.const 0 i32.const 20 memory.fill - global.get $assembly/api/interpreter + global.get $~lib/memory/__stack_pointer i32.const 0 - i32.eq - if - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end + local.get $input + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/api-internal/VmInput#get:program + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $input + local.set $4 global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/api-internal/VmInput#get:registers + local.set $4 global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 + local.get $4 i32.store offset=4 - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 19792 - i32.const 142 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int + local.get $4 + local.get $input + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/api-internal/VmInput#get:memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 i32.store offset=8 + local.get $4 + call $assembly/interpreter/Interpreter#constructor + local.tee $int + i32.store offset=16 + local.get $int + local.set $4 global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $useSbrkGas + call $assembly/interpreter/Interpreter#set:useSbrkGas local.get $int local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 - i32.store offset=12 + i32.store local.get $4 - call $assembly/interpreter/Interpreter#get:memory + local.get $input + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/api-internal/VmInput#get:pc + call $assembly/interpreter/Interpreter#set:nextPc + local.get $int + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/interpreter/Interpreter#get:gas local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - local.get $index - call $assembly/memory/Memory#pageDump - local.tee $page - i32.store offset=16 - local.get $page - i32.const 0 - i32.eq - if - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $page + local.get $input + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/api-internal/VmInput#get:gas + call $assembly/gas/GasCounter#set@override + local.get $int + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $logs + call $assembly/api-internal/executeProgram local.set $4 global.get $~lib/memory/__stack_pointer i32.const 20 @@ -42938,104 +45235,144 @@ local.get $4 return ) - (func $assembly/api/setMemory (param $address i32) (param $data i32) - (local $2 i32) - (local $int i32) - (local $end i32) - (local $i i32) + (func $assembly/api-utils/runProgram (param $program i32) (param $initialGas i64) (param $programCounter i32) (param $logs i32) (param $useSbrkGas i32) (result i32) + (local $vmInput i32) (local $6 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + i32.const 0 + i32.const 20 + memory.fill global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter i32.const 0 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end + local.get $program + local.set $6 global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/spi/StandardProgram#get:program + local.set $6 global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $2 + local.get $6 i32.store - local.get $2 - if (result i32) - local.get $2 - else - i32.const 9488 - i32.const 19792 - i32.const 155 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int + local.get $6 + local.get $program + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/spi/StandardProgram#get:memory + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 i32.store offset=4 - local.get $address - local.get $data + local.get $6 + local.get $program + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/spi/StandardProgram#get:registers local.set $6 global.get $~lib/memory/__stack_pointer local.get $6 i32.store offset=8 local.get $6 - call $~lib/typedarray/Uint8Array#get:length + call $assembly/api-internal/VmInput#constructor + local.tee $vmInput + i32.store offset=16 + local.get $vmInput + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $initialGas + call $assembly/api-internal/VmInput#set:gas + local.get $vmInput + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $programCounter + call $assembly/api-internal/VmInput#set:pc + local.get $vmInput + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $logs + local.get $useSbrkGas + call $assembly/api-internal/runVm + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 20 i32.add - local.set $end - local.get $address - local.set $i - loop $for-loop|0 - local.get $i - local.get $end - i32.lt_u - if - local.get $int - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/interpreter/Interpreter#get:memory - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $i - local.get $data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $i - local.get $address - i32.sub - call $~lib/typedarray/Uint8Array#__get - call $assembly/memory/Memory#setU8 - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) + (func $assembly/api-utils/runProgram@varargs (param $program i32) (param $initialGas i64) (param $programCounter i32) (param $logs i32) (param $useSbrkGas i32) (result i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $4of4 + block $3of4 + block $2of4 + block $1of4 + block $0of4 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of4 $1of4 $2of4 $3of4 $4of4 $outOfRange + end + unreachable + end + i64.const 0 + local.set $initialGas + end + i32.const 0 + local.set $programCounter + end + i32.const 0 + local.set $logs end + i32.const 0 + local.set $useSbrkGas end + local.get $program + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 16 + local.get $5 + i32.store + local.get $5 + local.get $initialGas + local.get $programCounter + local.get $logs + local.get $useSbrkGas + call $assembly/api-utils/runProgram + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer + local.get $5 ) (func $assembly/gas/GasCounterU64#set (param $this i32) (param $g i64) (local $2 i32) @@ -43095,6 +45432,25 @@ call $assembly/gas/GasCounterU64#get:gas i64.const 0 i64.lt_s + if + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i64.const 0 + call $assembly/gas/GasCounterU64#set:gas + i32.const 1 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i32.const 0 local.set $2 global.get $~lib/memory/__stack_pointer i32.const 8 @@ -43584,7 +45940,7 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) (local $2 i32) global.get $~lib/memory/__stack_pointer i32.const 4 @@ -43594,13 +45950,15 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store + i32.const 0 + drop local.get $this local.set $2 global.get $~lib/memory/__stack_pointer local.get $2 i32.store local.get $2 - call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env + call $~lib/array/Array#get:buffer local.get $cookie call $~lib/rt/itcms/__visit global.get $~lib/memory/__stack_pointer @@ -43608,8 +45966,11 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub @@ -43618,15 +45979,56 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store - i32.const 0 + i32.const 1 drop local.get $this - local.set $2 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $5 i32.store - local.get $2 - call $~lib/array/Array#get:buffer + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer local.get $cookie call $~lib/rt/itcms/__visit global.get $~lib/memory/__stack_pointer @@ -43634,8 +46036,11 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $cur i32) + (local $end i32) + (local $val i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub @@ -43644,15 +46049,56 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store - i32.const 0 + i32.const 1 drop local.get $this - local.set $2 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $5 i32.store - local.get $2 - call $~lib/array/Array#get:buffer + local.get $5 + call $~lib/array/Array#get:dataStart + local.set $cur + local.get $cur + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:length_ + i32.const 2 + i32.shl + i32.add + local.set $end + loop $while-continue|0 + local.get $cur + local.get $end + i32.lt_u + if + local.get $cur + i32.load + local.set $val + local.get $val + if + local.get $val + local.get $cookie + call $~lib/rt/itcms/__visit + end + local.get $cur + i32.const 4 + i32.add + local.set $cur + br $while-continue|0 + end + end + local.get $this + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/array/Array#get:buffer local.get $cookie call $~lib/rt/itcms/__visit global.get $~lib/memory/__stack_pointer @@ -43660,7 +46106,7 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) (local $cur i32) (local $end i32) (local $val i32) @@ -43681,7 +46127,7 @@ local.get $5 i32.store local.get $5 - call $~lib/array/Array#get:dataStart + call $~lib/array/Array#get:dataStart local.set $cur local.get $cur local.get $this @@ -43690,7 +46136,7 @@ local.get $5 i32.store local.get $5 - call $~lib/array/Array#get:length_ + call $~lib/array/Array#get:length_ i32.const 2 i32.shl i32.add @@ -43722,7 +46168,7 @@ local.get $5 i32.store local.get $5 - call $~lib/array/Array#get:buffer + call $~lib/array/Array#get:buffer local.get $cookie call $~lib/rt/itcms/__visit global.get $~lib/memory/__stack_pointer @@ -43730,7 +46176,7 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) (local $cur i32) (local $end i32) (local $val i32) @@ -43751,7 +46197,7 @@ local.get $5 i32.store local.get $5 - call $~lib/array/Array#get:dataStart + call $~lib/array/Array#get:dataStart local.set $cur local.get $cur local.get $this @@ -43760,7 +46206,7 @@ local.get $5 i32.store local.get $5 - call $~lib/array/Array#get:length_ + call $~lib/array/Array#get:length_ i32.const 2 i32.shl i32.add @@ -43792,7 +46238,7 @@ local.get $5 i32.store local.get $5 - call $~lib/array/Array#get:buffer + call $~lib/array/Array#get:buffer local.get $cookie call $~lib/rt/itcms/__visit global.get $~lib/memory/__stack_pointer @@ -43800,11 +46246,39 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $~lib/array/Array<~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + i32.const 0 + drop + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $"~lib/map/Map#__visit" (param $this i32) (param $cookie i32) + (local $entries i32) (local $cur i32) (local $end i32) + (local $entry i32) (local $val i32) - (local $5 i32) + (local $7 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub @@ -43813,26 +46287,40 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store - i32.const 1 - drop local.get $this - local.set $5 + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $7 i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:dataStart + local.get $7 + call $"~lib/map/Map#get:buckets" + local.get $cookie + call $~lib/rt/itcms/__visit + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + local.get $7 + call $"~lib/map/Map#get:entries" + local.set $entries + i32.const 1 + drop + local.get $entries local.set $cur local.get $cur local.get $this - local.set $5 + local.set $7 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $7 i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:length_ - i32.const 2 - i32.shl + local.get $7 + call $"~lib/map/Map#get:entriesOffset" + block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.7" + end + i32.mul i32.add local.set $end loop $while-continue|0 @@ -43841,28 +46329,37 @@ i32.lt_u if local.get $cur - i32.load - local.set $val - local.get $val + local.set $entry + local.get $entry + call $"~lib/map/MapEntry#get:taggedNext" + i32.const 1 + i32.and + i32.eqz if + i32.const 0 + drop + i32.const 1 + drop + local.get $entry + call $"~lib/map/MapEntry#get:value" + local.set $val + i32.const 0 + drop local.get $val local.get $cookie call $~lib/rt/itcms/__visit end local.get $cur - i32.const 4 + block $"~lib/map/ENTRY_SIZE|inlined.8" (result i32) + i32.const 12 + br $"~lib/map/ENTRY_SIZE|inlined.8" + end i32.add local.set $cur br $while-continue|0 end end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:buffer + local.get $entries local.get $cookie call $~lib/rt/itcms/__visit global.get $~lib/memory/__stack_pointer @@ -43870,7 +46367,7 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) (local $2 i32) global.get $~lib/memory/__stack_pointer i32.const 4 @@ -43886,7 +46383,7 @@ local.get $2 i32.store local.get $2 - call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env + call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env local.get $cookie call $~lib/rt/itcms/__visit global.get $~lib/memory/__stack_pointer @@ -43894,7 +46391,7 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) + (func $~lib/array/Array<~lib/string/String>#__visit (param $this i32) (param $cookie i32) (local $cur i32) (local $end i32) (local $val i32) @@ -43915,7 +46412,7 @@ local.get $5 i32.store local.get $5 - call $~lib/array/Array#get:dataStart + call $~lib/array/Array<~lib/string/String>#get:dataStart local.set $cur local.get $cur local.get $this @@ -43924,7 +46421,7 @@ local.get $5 i32.store local.get $5 - call $~lib/array/Array#get:length_ + call $~lib/array/Array<~lib/string/String>#get:length_ i32.const 2 i32.shl i32.add @@ -43956,7 +46453,31 @@ local.get $5 i32.store local.get $5 - call $~lib/array/Array#get:buffer + call $~lib/array/Array<~lib/string/String>#get:buffer + local.get $cookie + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $this + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env local.get $cookie call $~lib/rt/itcms/__visit global.get $~lib/memory/__stack_pointer @@ -44134,18 +46655,20 @@ local.get $3 return ) - (func $~lib/util/number/utoa32 (param $value i32) (param $radix i32) (result i32) + (func $~lib/util/number/itoa32 (param $value i32) (param $radix i32) (result i32) + (local $sign i32) (local $out i32) (local $decimals i32) (local $buffer i32) (local $num i32) (local $offset i32) - (local $decimals|7 i32) - (local $buffer|8 i32) - (local $num|9 i32) - (local $offset|10 i32) - (local $decimals|11 i32) - (local $12 i32) + (local $decimals|8 i32) + (local $buffer|9 i32) + (local $num|10 i32) + (local $offset|11 i32) + (local $val32 i32) + (local $decimals|13 i32) + (local $14 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub @@ -44165,9 +46688,9 @@ i32.gt_s end if - i32.const 14608 - i32.const 14736 - i32.const 350 + i32.const 14864 + i32.const 14992 + i32.const 373 i32.const 5 call $~lib/builtins/abort unreachable @@ -44175,15 +46698,28 @@ local.get $value i32.eqz if - i32.const 14800 - local.set $12 + i32.const 15056 + local.set $14 global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $12 + local.get $14 return end + local.get $value + i32.const 31 + i32.shr_u + i32.const 1 + i32.shl + local.set $sign + local.get $sign + if + i32.const 0 + local.get $value + i32.sub + local.set $value + end local.get $radix i32.const 10 i32.eq @@ -44195,11 +46731,15 @@ local.get $decimals i32.const 1 i32.shl + local.get $sign + i32.add i32.const 2 call $~lib/rt/itcms/__new local.tee $out i32.store local.get $out + local.get $sign + i32.add local.set $buffer local.get $value local.set $num @@ -44226,75 +46766,89 @@ i32.shr_s i32.const 1 i32.add - local.set $decimals|7 + local.set $decimals|8 global.get $~lib/memory/__stack_pointer - local.get $decimals|7 + local.get $decimals|8 i32.const 1 i32.shl + local.get $sign + i32.add i32.const 2 call $~lib/rt/itcms/__new local.tee $out i32.store local.get $out - local.set $buffer|8 + local.get $sign + i32.add + local.set $buffer|9 local.get $value - local.set $num|9 - local.get $decimals|7 - local.set $offset|10 + local.set $num|10 + local.get $decimals|8 + local.set $offset|11 i32.const 0 i32.const 1 i32.ge_s drop - local.get $buffer|8 - local.get $num|9 + local.get $buffer|9 + local.get $num|10 i64.extend_i32_u - local.get $offset|10 + local.get $offset|11 call $~lib/util/number/utoa_hex_lut else local.get $value + local.set $val32 + local.get $val32 i64.extend_i32_u local.get $radix call $~lib/util/number/ulog_base - local.set $decimals|11 + local.set $decimals|13 global.get $~lib/memory/__stack_pointer - local.get $decimals|11 + local.get $decimals|13 i32.const 1 i32.shl + local.get $sign + i32.add i32.const 2 call $~lib/rt/itcms/__new local.tee $out i32.store local.get $out - local.get $value + local.get $sign + i32.add + local.get $val32 i64.extend_i32_u - local.get $decimals|11 + local.get $decimals|13 local.get $radix call $~lib/util/number/utoa64_any_core end end + local.get $sign + if + local.get $out + i32.const 45 + i32.store16 + end local.get $out - local.set $12 + local.set $14 global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $12 + local.get $14 return ) - (func $~lib/util/number/itoa32 (param $value i32) (param $radix i32) (result i32) - (local $sign i32) + (func $~lib/util/number/utoa32 (param $value i32) (param $radix i32) (result i32) (local $out i32) (local $decimals i32) (local $buffer i32) (local $num i32) (local $offset i32) - (local $decimals|8 i32) - (local $buffer|9 i32) - (local $num|10 i32) - (local $offset|11 i32) - (local $val32 i32) - (local $decimals|13 i32) - (local $14 i32) + (local $decimals|7 i32) + (local $buffer|8 i32) + (local $num|9 i32) + (local $offset|10 i32) + (local $decimals|11 i32) + (local $12 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub @@ -44314,9 +46868,9 @@ i32.gt_s end if - i32.const 14608 - i32.const 14736 - i32.const 373 + i32.const 14864 + i32.const 14992 + i32.const 350 i32.const 5 call $~lib/builtins/abort unreachable @@ -44324,28 +46878,15 @@ local.get $value i32.eqz if - i32.const 14800 - local.set $14 + i32.const 15056 + local.set $12 global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $14 + local.get $12 return end - local.get $value - i32.const 31 - i32.shr_u - i32.const 1 - i32.shl - local.set $sign - local.get $sign - if - i32.const 0 - local.get $value - i32.sub - local.set $value - end local.get $radix i32.const 10 i32.eq @@ -44357,15 +46898,11 @@ local.get $decimals i32.const 1 i32.shl - local.get $sign - i32.add i32.const 2 call $~lib/rt/itcms/__new local.tee $out i32.store local.get $out - local.get $sign - i32.add local.set $buffer local.get $value local.set $num @@ -44392,78 +46929,62 @@ i32.shr_s i32.const 1 i32.add - local.set $decimals|8 + local.set $decimals|7 global.get $~lib/memory/__stack_pointer - local.get $decimals|8 + local.get $decimals|7 i32.const 1 i32.shl - local.get $sign - i32.add i32.const 2 call $~lib/rt/itcms/__new local.tee $out i32.store local.get $out - local.get $sign - i32.add - local.set $buffer|9 + local.set $buffer|8 local.get $value - local.set $num|10 - local.get $decimals|8 - local.set $offset|11 + local.set $num|9 + local.get $decimals|7 + local.set $offset|10 i32.const 0 i32.const 1 i32.ge_s drop - local.get $buffer|9 - local.get $num|10 + local.get $buffer|8 + local.get $num|9 i64.extend_i32_u - local.get $offset|11 + local.get $offset|10 call $~lib/util/number/utoa_hex_lut else local.get $value - local.set $val32 - local.get $val32 i64.extend_i32_u local.get $radix call $~lib/util/number/ulog_base - local.set $decimals|13 + local.set $decimals|11 global.get $~lib/memory/__stack_pointer - local.get $decimals|13 + local.get $decimals|11 i32.const 1 i32.shl - local.get $sign - i32.add i32.const 2 call $~lib/rt/itcms/__new local.tee $out i32.store local.get $out - local.get $sign - i32.add - local.get $val32 + local.get $value i64.extend_i32_u - local.get $decimals|13 + local.get $decimals|11 local.get $radix call $~lib/util/number/utoa64_any_core end end - local.get $sign - if - local.get $out - i32.const 45 - i32.store16 - end local.get $out - local.set $14 + local.set $12 global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $14 + local.get $12 return ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) (local $outSize i32) (local $out i32) (local $4 i32) @@ -44477,55 +46998,7 @@ i32.store local.get $length i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 2 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 32 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 3 i32.shr_u i32.gt_u if @@ -44537,60 +47010,12 @@ unreachable end local.get $length - i32.const 3 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 14 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 2 i32.shl local.set $outSize global.get $~lib/memory/__stack_pointer local.get $outSize - i32.const 35 + i32.const 39 call $~lib/rt/itcms/__new local.tee $out i32.store @@ -44643,8 +47068,8 @@ i32.gt_s end if - i32.const 14608 - i32.const 14736 + i32.const 14864 + i32.const 14992 i32.const 401 i32.const 5 call $~lib/builtins/abort @@ -44655,7 +47080,7 @@ i64.ne i32.eqz if - i32.const 14800 + i32.const 15056 local.set $17 global.get $~lib/memory/__stack_pointer i32.const 4 @@ -44794,6 +47219,150 @@ local.get $17 return ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 2 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 32 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 3 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 3 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 14 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) + (local $outSize i32) + (local $out i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $length + i32.const 1073741820 + i32.const 2 + i32.shr_u + i32.gt_u + if + i32.const 8176 + i32.const 8288 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + local.get $length + i32.const 2 + i32.shl + local.set $outSize + global.get $~lib/memory/__stack_pointer + local.get $outSize + i32.const 35 + call $~lib/rt/itcms/__new + local.tee $out + i32.store + i32.const 2 + global.get $~lib/shared/runtime/Runtime.Incremental + i32.ne + drop + local.get $out + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) (func $~lib/util/number/itoa64 (param $value i64) (param $radix i32) (result i32) (local $sign i32) (local $out i32) @@ -44831,8 +47400,8 @@ i32.gt_s end if - i32.const 14608 - i32.const 14736 + i32.const 14864 + i32.const 14992 i32.const 431 i32.const 5 call $~lib/builtins/abort @@ -44843,7 +47412,7 @@ i64.ne i32.eqz if - i32.const 14800 + i32.const 15056 local.set $18 global.get $~lib/memory/__stack_pointer i32.const 4 @@ -45018,77 +47587,68 @@ local.get $18 return ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) + (func $export:assembly/api-internal/getAssembly (param $0 i32) (result i32) + (local $1 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - i32.const 0 + local.get $0 i32.store - local.get $length - i32.const 1073741820 - i32.const 0 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 0 - i32.shl - local.set $outSize + local.get $0 + call $assembly/api-internal/getAssembly + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 58 - call $~lib/rt/itcms/__new - local.tee $out + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + ) + (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + local.get $0 i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 + local.get $0 + call $assembly/program-build/wrapAsProgram + local.set $1 global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 - return + local.get $1 ) - (func $export:assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) + (func $export:assembly/api-debugger/resetJAM@varargs (param $0 i32) (param $1 f64) (param $2 i64) (param $3 i32) (param $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer local.get $0 i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 local.get $0 local.get $1 local.get $2 - call $assembly/index/disassemble - local.set $3 + local.get $3 + local.get $4 + call $assembly/api-debugger/resetJAM@varargs global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 ) - (func $export:assembly/index/runProgram (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) + (func $export:assembly/api-debugger/resetGeneric@varargs (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -45103,37 +47663,44 @@ local.get $0 local.get $1 local.get $2 - call $assembly/index/runProgram - local.set $3 + local.get $3 + call $assembly/api-debugger/resetGeneric@varargs global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 ) - (func $export:assembly/api-generic/runVm@varargs (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) + (func $export:assembly/api-debugger/resetGenericWithMemory@varargs (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) (param $5 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer local.get $0 i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 local.get $0 local.get $1 local.get $2 - call $assembly/api-generic/runVm@varargs - local.set $3 + local.get $3 + local.get $4 + local.get $5 + call $assembly/api-debugger/resetGenericWithMemory@varargs global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 ) - (func $export:assembly/api-generic/getAssembly (param $0 i32) (result i32) - (local $1 i32) + (func $export:assembly/api-debugger/setRegisters (param $0 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub @@ -45143,114 +47710,129 @@ local.get $0 i32.store local.get $0 - call $assembly/api-generic/getAssembly - local.set $1 + call $assembly/api-debugger/setRegisters global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $1 ) - (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) - (local $1 i32) + (func $export:assembly/api-debugger/setMemory (param $0 i32) (param $1 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $1 i32.store local.get $0 - call $assembly/program-build/wrapAsProgram - local.set $1 + local.get $1 + call $assembly/api-debugger/setMemory global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $1 ) - (func $export:assembly/api/resetGeneric (param $0 i32) (param $1 i32) (param $2 i64) + (func $export:assembly/api-utils/getGasCosts (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer local.get $0 i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 local.get $0 local.get $1 local.get $2 - call $assembly/api/resetGeneric + call $assembly/api-utils/getGasCosts + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer + local.get $3 ) - (func $export:assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) + (func $export:assembly/api-utils/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer local.get $0 i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 local.get $0 local.get $1 local.get $2 - local.get $3 - local.get $4 - call $assembly/api/resetGenericWithMemory + call $assembly/api-utils/disassemble + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer + local.get $3 ) - (func $export:assembly/api/setRegisters (param $0 i32) + (func $export:assembly/api-utils/prepareProgram (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (result i32) + (local $7 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $2 i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=16 local.get $0 - call $assembly/api/setRegisters + local.get $1 + local.get $2 + local.get $3 + local.get $4 + local.get $5 + local.get $6 + call $assembly/api-utils/prepareProgram + local.set $7 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer + local.get $7 ) - (func $export:assembly/api/setMemory (param $0 i32) (param $1 i32) + (func $export:assembly/api-utils/runProgram@varargs (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) (param $4 i32) (result i32) + (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $0 i32.store local.get $0 local.get $1 - call $assembly/api/setMemory + local.get $2 + local.get $3 + local.get $4 + call $assembly/api-utils/runProgram@varargs + local.set $5 global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer + local.get $5 ) ) diff --git a/build/release.d.ts b/build/release.d.ts index 97c330c..08a7a0a 100644 --- a/build/release.d.ts +++ b/build/release.d.ts @@ -1,45 +1,7 @@ /** Exported memory */ export declare const memory: WebAssembly.Memory; -/** assembly/index/InputKind */ -export declare enum InputKind { - /** @type `i32` */ - Generic, - /** @type `i32` */ - SPI, -} -/** assembly/index/HasMetadata */ -export declare enum HasMetadata { - /** @type `i32` */ - Yes, - /** @type `i32` */ - No, -} /** - * assembly/index/disassemble - * @param input `~lib/array/Array` - * @param kind `i32` - * @param withMetadata `i32` - * @returns `~lib/string/String` - */ -export declare function disassemble(input: Array, kind: number, withMetadata: number): string; -/** - * assembly/index/runProgram - * @param input `~lib/array/Array` - * @param registers `~lib/array/Array` - * @param kind `i32` - * @returns `assembly/api-generic/VmOutput` - */ -export declare function runProgram(input: Array, registers: Array, kind: number): __Record44; -/** - * assembly/api-generic/runVm - * @param input `assembly/api-generic/VmInput` - * @param logs `bool` - * @param useSbrkGas `bool` - * @returns `assembly/api-generic/VmOutput` - */ -export declare function runVm(input: __Record47, logs?: boolean, useSbrkGas?: boolean): __Record44; -/** - * assembly/api-generic/getAssembly + * assembly/api-internal/getAssembly * @param p `assembly/program/Program` * @returns `~lib/string/String` */ @@ -51,107 +13,160 @@ export declare function getAssembly(p: __Internref30): string; */ export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array; /** - * assembly/api/resetGeneric + * assembly/api-debugger/resetJAM + * @param program `~lib/array/Array` + * @param pc `f64` + * @param initialGas `i64` + * @param args `~lib/array/Array` + * @param hasMetadata `bool` + */ +export declare function resetJAM(program: Array, pc: number, initialGas: bigint, args: Array, hasMetadata?: boolean): void; +/** + * assembly/api-debugger/resetGeneric * @param program `~lib/array/Array` * @param flatRegisters `~lib/array/Array` * @param initialGas `i64` + * @param hasMetadata `bool` */ -export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint): void; +export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint, hasMetadata?: boolean): void; /** - * assembly/api/resetGenericWithMemory + * assembly/api-debugger/resetGenericWithMemory * @param program `~lib/array/Array` * @param flatRegisters `~lib/array/Array` * @param pageMap `~lib/typedarray/Uint8Array` * @param chunks `~lib/typedarray/Uint8Array` * @param initialGas `i64` + * @param hasMetadata `bool` */ -export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint): void; +export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint, hasMetadata?: boolean): void; /** - * assembly/api/nextStep + * assembly/api-debugger/nextStep * @returns `bool` */ export declare function nextStep(): boolean; /** - * assembly/api/nSteps + * assembly/api-debugger/nSteps * @param steps `u32` * @returns `bool` */ export declare function nSteps(steps: number): boolean; /** - * assembly/api/getProgramCounter + * assembly/api-debugger/getProgramCounter * @returns `u32` */ export declare function getProgramCounter(): number; /** - * assembly/api/setNextProgramCounter + * assembly/api-debugger/setNextProgramCounter * @param pc `u32` */ export declare function setNextProgramCounter(pc: number): void; /** - * assembly/api/getStatus + * assembly/api-debugger/getStatus * @returns `u8` */ export declare function getStatus(): number; /** - * assembly/api/getExitArg + * assembly/api-debugger/getExitArg * @returns `u32` */ export declare function getExitArg(): number; /** - * assembly/api/getGasLeft + * assembly/api-debugger/getGasLeft * @returns `i64` */ export declare function getGasLeft(): bigint; /** - * assembly/api/setGasLeft + * assembly/api-debugger/setGasLeft * @param gas `i64` */ export declare function setGasLeft(gas: bigint): void; /** - * assembly/api/getRegisters + * assembly/api-debugger/getRegisters * @returns `~lib/typedarray/Uint8Array` */ export declare function getRegisters(): Uint8Array; /** - * assembly/api/setRegisters + * assembly/api-debugger/setRegisters * @param flatRegisters `~lib/array/Array` */ export declare function setRegisters(flatRegisters: Array): void; /** - * assembly/api/getPageDump + * assembly/api-debugger/getPageDump * @param index `u32` * @returns `~lib/typedarray/Uint8Array` */ export declare function getPageDump(index: number): Uint8Array; /** - * assembly/api/setMemory + * assembly/api-debugger/setMemory * @param address `u32` * @param data `~lib/typedarray/Uint8Array` */ export declare function setMemory(address: number, data: Uint8Array): void; -/** assembly/api-generic/InitialChunk */ -declare interface __Record45 { - /** @type `u32` */ - address: number | TOmittable; - /** @type `~lib/array/Array` */ - data: Array; +/** assembly/api-utils/InputKind */ +export declare enum InputKind { + /** @type `i32` */ + Generic, + /** @type `i32` */ + SPI, } -/** assembly/api-generic/VmOutput */ -declare interface __Record44 { +/** assembly/api-utils/HasMetadata */ +export declare enum HasMetadata { /** @type `i32` */ - status: number | TOmittable; - /** @type `~lib/array/Array` */ - registers: Array; + Yes, + /** @type `i32` */ + No, +} +/** + * assembly/api-utils/getGasCosts + * @param input `~lib/array/Array` + * @param kind `i32` + * @param withMetadata `i32` + * @returns `~lib/array/Array` + */ +export declare function getGasCosts(input: Array, kind: number, withMetadata: number): Array<__Record54>; +/** + * assembly/api-utils/disassemble + * @param input `~lib/array/Array` + * @param kind `i32` + * @param withMetadata `i32` + * @returns `~lib/string/String` + */ +export declare function disassemble(input: Array, kind: number, withMetadata: number): string; +/** + * assembly/api-utils/prepareProgram + * @param kind `i32` + * @param hasMetadata `i32` + * @param program `~lib/array/Array` + * @param initialRegisters `~lib/array/Array` + * @param initialPageMap `~lib/array/Array` + * @param initialMemory `~lib/array/Array` + * @param args `~lib/array/Array` + * @returns `assembly/spi/StandardProgram` + */ +export declare function prepareProgram(kind: number, hasMetadata: number, program: Array, initialRegisters: Array, initialPageMap: Array<__Record48>, initialMemory: Array<__Record50>, args: Array): __Internref44; +/** + * assembly/api-utils/runProgram + * @param program `assembly/spi/StandardProgram` + * @param initialGas `i64` + * @param programCounter `u32` + * @param logs `bool` + * @param useSbrkGas `bool` + * @returns `assembly/api-internal/VmOutput` + */ +export declare function runProgram(program: __Internref44, initialGas?: bigint, programCounter?: number, logs?: boolean, useSbrkGas?: boolean): __Record59; +/** assembly/program/Program */ +declare class __Internref30 extends Number { + private __nominal30: symbol; + private __nominal0: symbol; +} +/** assembly/gas-costs/BlockGasCost */ +declare interface __Record54 { /** @type `u32` */ pc: number | TOmittable; - /** @type `~lib/array/Array` */ - memory: Array<__Record45>; - /** @type `i64` */ + /** @type `u64` */ gas: bigint | TOmittable; - /** @type `u32` */ - exitCode: number | TOmittable; } -/** assembly/api-generic/InitialPage */ +/** assembly/api-internal/InitialPage */ declare interface __Record48 { /** @type `u32` */ address: number | TOmittable; @@ -160,23 +175,30 @@ declare interface __Record48 { /** @type `i32` */ access: number | TOmittable; } -/** assembly/api-generic/VmInput */ -declare interface __Record47 { +/** assembly/api-internal/InitialChunk */ +declare interface __Record50 { + /** @type `u32` */ + address: number | TOmittable; + /** @type `~lib/array/Array` */ + data: Array; +} +/** assembly/spi/StandardProgram */ +declare class __Internref44 extends Number { + private __nominal44: symbol; + private __nominal0: symbol; +} +/** assembly/api-internal/VmOutput */ +declare interface __Record59 { + /** @type `i32` */ + status: number | TOmittable; /** @type `~lib/array/Array` */ registers: Array; /** @type `u32` */ pc: number | TOmittable; + /** @type `~lib/array/Array` */ + memory: Array<__Record50>; /** @type `i64` */ gas: bigint | TOmittable; - /** @type `~lib/array/Array` */ - program: Array; - /** @type `~lib/array/Array` */ - pageMap: Array<__Record48>; - /** @type `~lib/array/Array` */ - memory: Array<__Record45>; -} -/** assembly/program/Program */ -declare class __Internref30 extends Number { - private __nominal30: symbol; - private __nominal0: symbol; + /** @type `u32` */ + exitCode: number | TOmittable; } diff --git a/build/release.js b/build/release.js index f4db6ff..5556b95 100644 --- a/build/release.js +++ b/build/release.js @@ -22,43 +22,8 @@ async function instantiate(module, imports = {}) { const { exports } = await WebAssembly.instantiate(module, adaptedImports); const memory = exports.memory || imports.env.memory; const adaptedExports = Object.setPrototypeOf({ - InputKind: (values => ( - // assembly/index/InputKind - values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", - values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", - values - ))({}), - HasMetadata: (values => ( - // assembly/index/HasMetadata - values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", - values[values.No = exports["HasMetadata.No"].valueOf()] = "No", - values - ))({}), - disassemble(input, kind, withMetadata) { - // assembly/index/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String - input = __lowerArray(__setU8, 27, 0, input) || __notnull(); - return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); - }, - runProgram(input, registers, kind) { - // assembly/index/runProgram(~lib/array/Array, ~lib/array/Array, i32) => assembly/api-generic/VmOutput - input = __retain(__lowerArray(__setU8, 27, 0, input) || __notnull()); - registers = __lowerArray(__setU64, 43, 3, registers) || __notnull(); - try { - return __liftRecord44(exports.runProgram(input, registers, kind) >>> 0); - } finally { - __release(input); - } - }, - runVm(input, logs, useSbrkGas) { - // assembly/api-generic/runVm(assembly/api-generic/VmInput, bool?, bool?) => assembly/api-generic/VmOutput - input = __lowerRecord47(input) || __notnull(); - logs = logs ? 1 : 0; - useSbrkGas = useSbrkGas ? 1 : 0; - exports.__setArgumentsLength(arguments.length); - return __liftRecord44(exports.runVm(input, logs, useSbrkGas) >>> 0); - }, getAssembly(p) { - // assembly/api-generic/getAssembly(assembly/program/Program) => ~lib/string/String + // assembly/api-internal/getAssembly(assembly/program/Program) => ~lib/string/String p = __lowerInternref(p) || __notnull(); return __liftString(exports.getAssembly(p) >>> 0); }, @@ -67,26 +32,43 @@ async function instantiate(module, imports = {}) { bytecode = __lowerTypedArray(Uint8Array, 5, 0, bytecode) || __notnull(); return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0); }, - resetGeneric(program, flatRegisters, initialGas) { - // assembly/api/resetGeneric(~lib/array/Array, ~lib/array/Array, i64) => void + resetJAM(program, pc, initialGas, args, hasMetadata) { + // assembly/api-debugger/resetJAM(~lib/array/Array, f64, i64, ~lib/array/Array, bool?) => void + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + initialGas = initialGas || 0n; + args = __lowerArray(__setU8, 27, 0, args) || __notnull(); + hasMetadata = hasMetadata ? 1 : 0; + try { + exports.__setArgumentsLength(arguments.length); + exports.resetJAM(program, pc, initialGas, args, hasMetadata); + } finally { + __release(program); + } + }, + resetGeneric(program, flatRegisters, initialGas, hasMetadata) { + // assembly/api-debugger/resetGeneric(~lib/array/Array, ~lib/array/Array, i64, bool?) => void program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); initialGas = initialGas || 0n; + hasMetadata = hasMetadata ? 1 : 0; try { - exports.resetGeneric(program, flatRegisters, initialGas); + exports.__setArgumentsLength(arguments.length); + exports.resetGeneric(program, flatRegisters, initialGas, hasMetadata); } finally { __release(program); } }, - resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas) { - // assembly/api/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64) => void + resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata) { + // assembly/api-debugger/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64, bool?) => void program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); flatRegisters = __retain(__lowerArray(__setU8, 27, 0, flatRegisters) || __notnull()); pageMap = __retain(__lowerTypedArray(Uint8Array, 5, 0, pageMap) || __notnull()); chunks = __lowerTypedArray(Uint8Array, 5, 0, chunks) || __notnull(); initialGas = initialGas || 0n; + hasMetadata = hasMetadata ? 1 : 0; try { - exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas); + exports.__setArgumentsLength(arguments.length); + exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata); } finally { __release(program); __release(flatRegisters); @@ -94,69 +76,103 @@ async function instantiate(module, imports = {}) { } }, nextStep() { - // assembly/api/nextStep() => bool + // assembly/api-debugger/nextStep() => bool return exports.nextStep() != 0; }, nSteps(steps) { - // assembly/api/nSteps(u32) => bool + // assembly/api-debugger/nSteps(u32) => bool return exports.nSteps(steps) != 0; }, getProgramCounter() { - // assembly/api/getProgramCounter() => u32 + // assembly/api-debugger/getProgramCounter() => u32 return exports.getProgramCounter() >>> 0; }, getExitArg() { - // assembly/api/getExitArg() => u32 + // assembly/api-debugger/getExitArg() => u32 return exports.getExitArg() >>> 0; }, setGasLeft(gas) { - // assembly/api/setGasLeft(i64) => void + // assembly/api-debugger/setGasLeft(i64) => void gas = gas || 0n; exports.setGasLeft(gas); }, getRegisters() { - // assembly/api/getRegisters() => ~lib/typedarray/Uint8Array + // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); }, setRegisters(flatRegisters) { - // assembly/api/setRegisters(~lib/array/Array) => void + // assembly/api-debugger/setRegisters(~lib/array/Array) => void flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); exports.setRegisters(flatRegisters); }, getPageDump(index) { - // assembly/api/getPageDump(u32) => ~lib/typedarray/Uint8Array + // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); }, setMemory(address, data) { - // assembly/api/setMemory(u32, ~lib/typedarray/Uint8Array) => void + // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); exports.setMemory(address, data); }, + InputKind: (values => ( + // assembly/api-utils/InputKind + values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", + values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", + values + ))({}), + HasMetadata: (values => ( + // assembly/api-utils/HasMetadata + values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", + values[values.No = exports["HasMetadata.No"].valueOf()] = "No", + values + ))({}), + getGasCosts(input, kind, withMetadata) { + // assembly/api-utils/getGasCosts(~lib/array/Array, i32, i32) => ~lib/array/Array + input = __lowerArray(__setU8, 27, 0, input) || __notnull(); + return __liftArray(pointer => __liftRecord54(__getU32(pointer)), 2, exports.getGasCosts(input, kind, withMetadata) >>> 0); + }, + disassemble(input, kind, withMetadata) { + // assembly/api-utils/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String + input = __lowerArray(__setU8, 27, 0, input) || __notnull(); + return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); + }, + prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) { + // assembly/api-utils/prepareProgram(i32, i32, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array) => assembly/spi/StandardProgram + program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); + initialRegisters = __retain(__lowerArray(__setU64, 56, 3, initialRegisters) || __notnull()); + initialPageMap = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, initialPageMap) || __notnull()); + initialMemory = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord50(value) || __notnull()); }, 51, 2, initialMemory) || __notnull()); + args = __lowerArray(__setU8, 27, 0, args) || __notnull(); + try { + return __liftInternref(exports.prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) >>> 0); + } finally { + __release(program); + __release(initialRegisters); + __release(initialPageMap); + __release(initialMemory); + } + }, + runProgram(program, initialGas, programCounter, logs, useSbrkGas) { + // assembly/api-utils/runProgram(assembly/spi/StandardProgram, i64?, u32?, bool?, bool?) => assembly/api-internal/VmOutput + program = __lowerInternref(program) || __notnull(); + initialGas = initialGas || 0n; + logs = logs ? 1 : 0; + useSbrkGas = useSbrkGas ? 1 : 0; + exports.__setArgumentsLength(arguments.length); + return __liftRecord59(exports.runProgram(program, initialGas, programCounter, logs, useSbrkGas) >>> 0); + }, }, exports); - function __liftRecord45(pointer) { - // assembly/api-generic/InitialChunk + function __liftRecord54(pointer) { + // assembly/gas-costs/BlockGasCost // Hint: Opt-out from lifting as a record by providing an empty constructor if (!pointer) return null; return { - address: __getU32(pointer + 0), - data: __liftArray(__getU8, 0, __getU32(pointer + 4)), - }; - } - function __liftRecord44(pointer) { - // assembly/api-generic/VmOutput - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - status: __getI32(pointer + 0), - registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), - pc: __getU32(pointer + 8), - memory: __liftArray(pointer => __liftRecord45(__getU32(pointer)), 2, __getU32(pointer + 12)), - gas: __getI64(pointer + 16), - exitCode: __getU32(pointer + 24), + pc: __getU32(pointer + 0), + gas: __getU64(pointer + 8), }; } function __lowerRecord48(value) { - // assembly/api-generic/InitialPage + // assembly/api-internal/InitialPage // Hint: Opt-out from lowering as a record by providing an empty constructor if (value == null) return 0; const pointer = exports.__pin(exports.__new(12, 48)); @@ -166,29 +182,37 @@ async function instantiate(module, imports = {}) { exports.__unpin(pointer); return pointer; } - function __lowerRecord45(value) { - // assembly/api-generic/InitialChunk + function __lowerRecord50(value) { + // assembly/api-internal/InitialChunk // Hint: Opt-out from lowering as a record by providing an empty constructor if (value == null) return 0; - const pointer = exports.__pin(exports.__new(8, 45)); + const pointer = exports.__pin(exports.__new(8, 50)); __setU32(pointer + 0, value.address); __setU32(pointer + 4, __lowerArray(__setU8, 27, 0, value.data) || __notnull()); exports.__unpin(pointer); return pointer; } - function __lowerRecord47(value) { - // assembly/api-generic/VmInput - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(28, 47)); - __setU32(pointer + 0, __lowerArray(__setU64, 43, 3, value.registers) || __notnull()); - __setU32(pointer + 4, value.pc); - __setU64(pointer + 8, value.gas || 0n); - __setU32(pointer + 16, __lowerArray(__setU8, 27, 0, value.program) || __notnull()); - __setU32(pointer + 20, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, value.pageMap) || __notnull()); - __setU32(pointer + 24, __lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord45(value) || __notnull()); }, 46, 2, value.memory) || __notnull()); - exports.__unpin(pointer); - return pointer; + function __liftRecord50(pointer) { + // assembly/api-internal/InitialChunk + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + address: __getU32(pointer + 0), + data: __liftArray(__getU8, 0, __getU32(pointer + 4)), + }; + } + function __liftRecord59(pointer) { + // assembly/api-internal/VmOutput + // Hint: Opt-out from lifting as a record by providing an empty constructor + if (!pointer) return null; + return { + status: __getI32(pointer + 0), + registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), + pc: __getU32(pointer + 8), + memory: __liftArray(pointer => __liftRecord50(__getU32(pointer)), 2, __getU32(pointer + 12)), + gas: __getI64(pointer + 16), + exitCode: __getU32(pointer + 24), + }; } function __liftString(pointer) { if (!pointer) return null; @@ -247,6 +271,13 @@ async function instantiate(module, imports = {}) { return header; } class Internref extends Number {} + const registry = new FinalizationRegistry(__release); + function __liftInternref(pointer) { + if (!pointer) return null; + const sentinel = new Internref(__retain(pointer)); + registry.register(sentinel, pointer); + return sentinel; + } function __lowerInternref(value) { if (value == null) return 0; if (value instanceof Internref) return value.valueOf(); @@ -341,13 +372,9 @@ async function instantiate(module, imports = {}) { } export const { memory, - InputKind, - HasMetadata, - disassemble, - runProgram, - runVm, getAssembly, wrapAsProgram, + resetJAM, resetGeneric, resetGenericWithMemory, nextStep, @@ -362,6 +389,12 @@ export const { setRegisters, getPageDump, setMemory, + InputKind, + HasMetadata, + getGasCosts, + disassemble, + prepareProgram, + runProgram, } = await (async url => instantiate( await (async () => { const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); diff --git a/build/release.wasm b/build/release.wasm index 5dbaeb3b3175e196f275a6e9299e4947e9fcf099..611743d556978750d7f8e7dd44de43f8b5202f4b 100644 GIT binary patch literal 96928 zcmdRX34C2gb@!cnpQLBqC;K{a5+`=z`<|4vQR=O&DVZeh)E(RPHZa% z+Qb&b0RsjE1PEY2tPWrkLs?u1R6qa&2Fy}$i%ZSYVp@N#DYUr7knjILXXf5{(vvKC ziB0m8?|n08&YU^hoLO&l^OCzv6h-EvX7)|V^5x6T@|$A$*YMRWk8XUNt$)gSF@>1ao%MuP{Bh+PRTIq-*6PcL#@{ci7+Nu@29?@9=y!$WqFU8ZPplk%- zIPL&?)FRl3QT{KWC-4#{F$tW&e-7-(CQwH`iIMiS$F(?aM{3Of+CW*Q5>06%U2W~{ zNqZ&g0_Bysl2j^3&8);z6qb z`t9P|qBZjC@|%}jHUCBZ(IasuF!)~|ife#;?)=;CSOWA*q7TO@E4}%)`Om!fu6v@7 z#M7@_c+b84&%R^ft*2f-f8qSacf2q;tgB4B?m1T`hfllW<|S9p@4xxhoBMA*_0Q%n zNoGt9Q?9u?Iil^x8yC)hanyz9J$EdOW_H|o5Vro z?(e_j##?S)GCw)8{jT|U-M#pwaWvz`8$mLfa_?R97xtqW3vcVcJ*tyZyJX4yyKcGj zrO_ATt`{%9`5wE(@g@3FTwOdL#hzuajvkL|^6pv?eK|fd{QakQ^xuB9)D?XtuAxlH zkFUm4@Y`i>6y|_+&$xR@|B~oyaeC_=OKw&Q=0{(Tr{1%8{yjG@p6^NcM%=mh-i7|x zrnqVvQ(hArD#JU?)RRs=>6FvYIOAz&o_W^U^K9=ko_XnImtS$^v#+}Pnrol)C(pg^ zdDlPxPhaq7H~gQ!_`f&abaVgGm;B{@%LdHL%*)LKW`%jsyu!TFtTeAOuQsnStITW7 z>&)xTpm~FNqj{5g$h_IS#k|!#Y~E(xZr)*5n|DIj-))A>d(3;y`^@{z2h0b}8uN(x zkomCrh?ze9u(jr6=HuqC%_qz!&8N(#%?9%~<}>EA<}vd*^Lg{PX4rhee9?T#JZ`>h zzGA*=Hkz-QubXd}P3D{CTjtwlv-ytsuKAw%zWF=z1M~OhN9G^RKbdXjC+4T-XXfYT zpUuCRUzqLYm*!v1znTAM9*zGR|JUO6?VXQot9&E=I~etHyDiPy?9Q)7_;=_h{CDU7 z%KLZZ-%cb9t}*y`v-~^oGQJPJ3jcObZ$y=OIlxl8^S5|(Pc0IUU1iRYAgDCV+_+-zTU3t{V9w3utbj?$BAeicjqJ8gJ7jE@MNyhZc1B;8D+CMG zOq!-Q8?)ReHO!@op?WERVfj}sLV{u$F!nHFnFc&_<7y)+a#nc!CXddEt0crzvG|<0 zlD@~71XXmmUFMKWHH!5iV~-QsOivpSXGwQ^T}sy)v5l{;EVrgDk1c%B+&FqRXxWz9 zp_)Cy&X!Vu>9;E$F@4Cj`J%L*A%YGV)kCB*{v0dSaBb zJ=4itSV(D1kJPRl8EyhMd=x zIRo*PD4f{J(l$HC?tbElCz2fh>)W-n8p&-78Wr2I0MsXW#a0$9wb_ys*s?3Zf}^}F zfONG-DvfO;L6t@Y+^ytoXl0tW;k_-dkoyz{idXvcqz~Ncqt4vKb{WFnl((VX0^#y1 zc3Gahco8|7C*)kB0N_Z3toX%?&WR)FP5Pz8w1F4Mg(yMP*No%AX!d-g$g-6_VISDk z*Qk(>G59DHRI+wfNr+goQ9D#=REc_=0xD)9WG)~Msj)p2$Ul0W1O~y|PCS%OUxRp4 zunNip9f%|qWRx=dr6;$d)yI8mOK9Z37Fnn|H!KeA6v2YWfnZ~#i-;lE7=leGSg0}^ z=mZ;6ux(9({hdc2Ap;_dMPv{d#bIGxpomhb<_VgQG?8!YAQZ5q zSFFinrdQH$iEYNYS@%3I$3GOxWe@MO_bdXvbwhMRwT9Fx5}_@M*dK&`s_KKnY(Yb; zJb_f|P{z7R+h9=duR-cXi8m&;jV01NUIYBOA$MlLV&GZ~6hB@BCRLee77Ovd{tuA=h*@_CVsu4qGGQ<)c~cJRXq(L{Frr}QP6 z2Lg{m?RdbMAiqx-ZKJwD9@?aNkcOc&3W%GKXZq@fUKC~VDh^d@_{67@OQN;C*(sDf0Don#`E<5?s#f~=r2jF>4|OBlVovsdrw<;LI-qd-E_Bwe!aV0{CW@UT>L6@ zHCZG{(6Rf#KT48VKm{E<(WnFVPTp7H@xuJOkE%z~bb5I<9umtatBPxfhgC48VVwG1 z-6JaQuGS;841GcmjJpTURU6g=ZS09tX>eNuAkrLqF@qL?6CIa=yV6Q%8Tzn)Hg<++ znRZJeEinfO7fR9A9Z3sN7!6p^gI{yHYM$z!gM;=$WB{i(VSVXhe7M% zKA5b+>c)8xmEgP={ek55TNZZvR`}GU;?+&EzF2>|fMiuN39x zcBEH;T=H&$G)en%B$~be2t3xpjks{$KZ>7wA~R-jFOo&nGNt%M?nfO~La2{Z}X;#K39UI+}l@`SR>pkg41op!v)c`Wue@KF@V0{AiKsj?0l zF}hfGq98Qv4V?zxFa2w7s7^7YYIiVDKn-L$EaAb}&LPXYqi%!Lc%B`|>M=|?&N`vl z-IQr}w61rfS=RgWXkd*UsP^@k8amC`M$hV!f+)HG=~vp$e&nUFi@-jzz6`+^yOA2h zrE}t}yUHH6iarR*-5qo{?8u}W;tTaKVZ+%wG0cKBirI)Y_Q4usI41h!JldV2-DwSi z)Bm%c^o3$Jpnz^mH4^PyNURZ8Uk?D%N|ara zK2ArHK&9;9w<6IkzT6`*0A3ctOOT}%>YnLmSo8B}A-krnzmNLPCecW^CrIecU$FwT zNKa*uN1VhEdkjo03P9~uJAqZ5RA*U0Dx?FE$`lli2FRdNB*xg&`z|oB#Ffxrgpz9! z^)Sjc3m^_ONU zG>*0hMwQJgD;o|$n*M}A4tQJ{UtXdNF({-30U8pqn|~ikw~pUY9xVX%k)5*?lr{_k zc02Uic8%$O9_h35TKHO!ERwScWwX8G+CH|z4y^lWMWKdQTy(8%7r23k{%vb=EyPcN zFaGc}z^1|+i8eBf`6vr;0{}4b!*fH~*;B}3M_BL<7plmv4%}ZABn}Yp&K^6orpWxyx!AS zTx23^7z6gg<2^C$1;{WY^T05W}ObW(!W-7o01 z*I-I-bRGSOOK_cm_<74Q11qD4;fzX@USrI%eQF&lbnbxYUQc(x-xKh71&LrRW|=&} z5Nji@8~+dwHn7Yk~w+hxVCPLM;dcFs`-?9XIh_gTwd#HOl>r# zWz&y4tWj?qKBIoboFnIS&pB%5(Q}SFCZBcuoP74NkWu(QyvA|-?ONeq!M@r|BxZA% z#eemGaEp^l;2$`n%=1I82221xk#k>Ql#U>MA>mgo3u@MS0~UgJN=42W?GZ|mcXfdM z>_2K%=_`Vqc9-MDOR0yku^xSWwuJo!2wf zM%np2)9i9QFRXh8Sx}f=(324ld_ua4q~gcKyphdpy9*SQ;T1lz&%`6*&Qcq@WQfVS8<=)v!#MkhSvFUz`^5>XGEc?|1tj9)qSi`!q4={2a8=0` z|AHnc1AW9-8^64F%4O@FL_l_Sd_4iW8alo%HmP6_@@NQ{JdHTt3PDcuoRch08e&w6 z7=j}}Fq#Z~)+`SE(Cg;O6|>O2_bGE?g+w5t!y}X=Bm)!t5z^3kU$4Z+1psG*lMsMUZfkFT7Soj@gY zibgFz{?pHlvwoH)#uCE>w2~CS!H0kA&!IdkYQsx1q#NgOtc6O@+zkB21#fG#-tuVf1zjAMl``e z*QPBBL6Pu;!KB#I^P{rFXwUiTfPP1PD>vp^Q-~TYI5B$)Nfokb5-}8LLm*@2dLb`W#o>ku_g(%wtnF;IkahjEAlp@v|Yp{EnfHQA{FYqQgoAfMZYTxvG^3HXQ8oK=Y? ztTsAu4@_t8wbG2zO89qIEo7WzbL*v_qN_%NGda}=c4i@Uw^C2{j9NLPJAH!d90jQwlk*AMFpLoj zO(-iyKZ!XbXpA+_o|Qe79R>P-`at0~nd0BeLg;!GCzOTZV-IAI(e7XCly~pCd`Gkk zPpFHm1*%K;hM#PpSML_84q`-dLJm9V^sSuZpka;A!=^A9-5y6>=>M0>;L5EL%P;OZ zu*3K}+@2ox+Kff&6^mst@UeRJEG+ERq0Eq%E-<%ouBvG1( z_>XillV(hflu2kM5e#|pa$}E_$q!K?SrUZE&M6dxnqMm&Ec68kFsc!~@&vuHJ{hlP z2M} z$yhf!+$RGn?oP9F@l4#a;+}2p+3ubl?pbxuDSQI$dWW_XZU4kxkU^Vyba?h#m zIn6yY_nhvYhq>qBd;cX3;4+wHQ27i9gd0 z9*Jbnfnk??mK_e0ce>=W?anZH=qN>Ujvaz0Dv)e;$>-Y5Ve-ICg?_pnm>EE?cgg43 z^5?z9JHzCmV-(57cIX(71T4SAv2HkW zFJJI4U-U0u@-L73moLi;7`@pc{Yr#a+g@;EaF$jEe=;~LNZ;(zHv&FPADpf5UjzJX z4-e|T?rZ#pf7#?;zUg1S6(}(6L{0{&>CxmzDKLmW3K9no`7Qp8ryi5Ok zz=!EWb%p;2z}G!Ixc4K^nXUfiAN|XZ{mVc3mu>##C;sK9{^e)#Lc4Mm{Tu|;)ia9+ z{O72Vk_>A!=3!t}wp zif1?YFgL(6?9zV^K7{EzUHTu;#4vs6B*pUt_;6ByXR}KmFm`j8KJXNUe;In>rv&ip zT{?n|^e--eA=|iU|o>v5(?fWd{zkxu=>umd{F?xOMgYIwrDJR9 z`Y?T)OMf%y4ATdnrg+{0I-eHc8FuM!MZIDAPM7{L_#CDWovC=<20ot|;Mwfb-wr;9 z=>ume{5wGZSpod8OJ9w8!}Ni(75<%oKRbkX>F)x3n7-4czZ-Oh>Fdu?JVW5mIRTz+ zF8w{=PmvD4@m}M4+xPjG_xqO*_?Hj*mo@(75&!Zbd4b;;I#=ucF!*yWVq+iaYDyfTM?rs>K6swuc@*+J&*MS6)_V#+=3hSUU;f(D zJnYJT0=zxXrbY1gNe}rc|MF@7vcbRnjeq%!fBCF`dCb3jPF}#Af%BEf&!e&DW765j zdqXb$Z^5)Meb}WBgRn4tn@j%!m=LB9UZD8D2qs(*;2(DBUjm*meWy!*9Lf`>4_&Bu zz6^RU4Df7r>0f~m!}NiR6#lDd*F^#RdY8TtLJZS4yL4FY+nem4f&k!gRrKYVW0DNXkt^&PM`AwG_omY=!>qN z9|GGK!+JLRoGoZ*Q_jGbT$#TIZC?t@toJ$pfR;ApZ1XukLQ9)+1|N6WwnAW!huDUF z4z_ONJ>ck0pYvn1rzvOX%MRN=p*>#?%WU>J+t8k-oPn>nGCx6kFct`G&FB0S*qU;N zea_E7TT{+9pYwCHv?*uctF9hwUB!D?kI(rR)KlhQk+KV(KxX}xO=?P_YSRg=|LM8_ z$dZXnSrEwmFPSOS1%)VmXI##^wpz_VW4J2D39;^@bY_e*9Kn2Hu)-npgK|y)AT{i( z)q)#bi8-OD<=lqJ5F$<>Lalx1MUBxmY$r-MzFx~0Z#kkYp>Us6oeCH;NnZk2Qa zIlUjM_(xX-_(`^M+7SzXnCdHc{iJVqbHo#yO}8`b;b5N=5*`%NeppuzY>q4bG42y{Z)2xb_uKH zr1gq}L&KUo)`e6YBu>0Eq~Tz3;U zyRs&)(2-{s<;kCv+hw?Fm_5r?JS`P}E@9+>rQo>-odWC~S016eKR7(VCiR0%0rvVI zWD1@?0SfL@mo-6Ca8}i<{AJ8iv=_z_?y(+A1rAu{e|j)m{$~fX^6Mv1`CBIE|Mnns z*__h?24@~zcnhysnTS_B7<5gpV! zOiIqgJP&t9f}wa6lPAR)U_UkKGQk#{6INx$!%Zu?OlUeY{Ue;lOJtUZ1kT*kwm>@* zC#B@s&E$?WY3vTJh+PzBw})jRLtO17_5ztqO*3+R#49Z5PlXM5hrQK`=K zLkD1*;v#_AIopR14!8Bbs3B};+J-;um6@*d!O$cxh38FL4WM8)zD%z0@XG1c&LjPt z!QB}A0fTE=%AmbO&E{orFA#R;>&ASZ&?M_d5XFTJDe5bvEd(3Kv*Td{uo2upg9GB= zK4$Xs_=;H#-Vp#X<1PuBW3m9|O{-K-(Zktf<7ahe${tyJcX1S(FMgj=!2NaZBE zw89SL+4*(1by@dg8y-hQGek{56t#u3=G?Vgv|Z3}4jePbz-9-r@oW&A%udB}2KN4f zbnd>!{Pm~XaUB$X&LyMerW^cNfvXXeV|FfYen@y2MTp|yH7#wl+gg7e#~Yn;lgetNN{KGdt9g4iAC=@C*==hNfKpA>d7DWk@-Jz@mN@mf+YL+#+j>ccD>p)9UFEUx8g38-j zeOl)sN#Pw%lCj6ZgEivnpGc0-tzn{wd=P>~n3UZTa?A_@o*0sx=7z*nFaU)ID9fSZQX*z^1LW0S~ELH4$A9-v{+M%n8?4(^-!uY_^ zOG2rGqgEH^qeYYIfuRe!&KE55wOE0}@|$!;dcNrUiTdIh;)_RkV><&5LK!L#i!L7e za3>F1jx-N66fzpiJji3(RvBV-!Ogj&YtBW2H;=_m!|Bdh1KFpHg0F*Z+(ms56ZKvS zq==b0r6HYVQq`Rj4TI0XiTU^pZpM z*+LjzaS$@9M+rfp`Z#Bs9iQ`3g|aA;^}56MJ|0|>(h*C`H85zHL>j1vW>B^w61S{q zU=)x5*w8|efnbI@et&dua{7xq94D~0>Vzh4Iy=w%D$*tX%k@^iF;V*G5XnC4aky9= z9)}%veKFM+)v#}C)fZzQ!w6MIpK7wZ$ylgac8~a8a2QPhxon&BL^xf~eimv^+2P?V z7!XuD_$q;bP@wwSAC1Bx-i$bC{)^UO@tclDL}gOUOiX@wRIYij0j1fAC&3zf;SRkG zp}8@v7xrneg`SiXR9nhs(dVMgq)T+rq>q`HH(4`beBL^JC~T?VAkpi%BwI`_(vb0x zWcG)sFp>^+B-_v+KfEVAXb;xQW9(DNE@p2P;sP7seX=Ev{`3ofe0njwwplUus{rnO zvIVfaP@laq&3Iy_2|cG-;XxfvT9_s+fyXSzHcgMins3h>#7{u*5xdcBbvavCSsRC$ryH-sa;N_B(;e82#Zco za^``x=)Zch_2nJ0o_s!l+HznlTK%`T=n>}bGF8;>P6Zc~iH}A^;H25?3l5|!xc|u( z?Uu^ExPs~*lPg%qeMGW#bkALMvnyD~O-7S130JVLcjn%dtgxis@Hr9p6Hwd6l5_W_ z&UThOeZnOJm)F6PPnVJhDu`MBWZT8hivV#Bm|DV8s{98R_?`M;*YSEdl7d35w>zKLf1dSR_;Z>^+(vsy@);j z2wS-qJ;}bc@{MlK+}`&ivN5C8DG<(cHOd{te$8@3SAh92^fnKKJERX0njSm^X<8A| zgtc1P@4Zj5!!7$7#FZ1KdT0lWe8ui>zqhXm#>WjZg(<@JDcl&@B+)~f(k3|{(v&ty z|09Qp^jk)fy~`hLQh-C9*h7-DEl$tnl?TDv&*EBa>s98@gxbKUNt$ACNpxI2rZ$=4w3$LS*X^NWKW^8`$<$GdmbqU z+Y?luJ;-W}EV;A*Ds?5hNJrl-fU3pu0}jgj{6Rg@sgLgu+nZ28poVdu*R&=x^-%yX zZ`4pCw3IdL?)P>erum@*O7o}y6dY|$tRpp)L0)P0BAfTOBJgti)(RVvF%eb37Mq1o z1$yssb*6VYmY2)z%MZr;+IfV8K0a1|5lZ3lM&&tUwYt=8(uw_0qGm7o6C6TZ{wMgF z&seSVfhzW_jLm|!HTa$n52a&IB)Jf<;d}dAuoJX!Tq{0in*u9}@0o~b^9rDXM!l+7 zM%#P06-swZx7B3b@>S3n-%T4Bc*$kB>~%RmiZzzpd>ebQ>0ytmo5yR>#FwFs69H{v z#eog#L+u{lA-41}{?LMW!vjlc8MkE@jZbMy*L{E3K_6I3_mQVfp~SEExrb@djZM^t zjZl4ruoLQE_d+@YUgbrRR_<5NJ`u-0X}?Y%F|hoAJNGwZd6)yFy`LqSkod=xtaoxg z7z%yrXty^e8f5IF`M&&6R*K-Om*KBWWNXv-!5#S zX!r(Wg&+1>&KT&yUW1SuUns{RraHEMX-48Quxa;FeBcTPppcWVY*bN%M@yzX&}ds$ zZ^thrb|B9sPFYs(WH7YsIqR@tzPc=L2f%%Kr~KRQps*`_$}*R(1svz z@VCd=zO3G%72!)Y%kmB>S=7kN8YJUBUClsj+7F_DAYFWY$3>6X zMU6Hzpk!y8Z#sC4?Ox$-P8|GLR1tHCd7hRTQYA5^{y zm5(axmCq{-)N*{~bI6Dn=tcQN^}$hJk%)!7cgm=|FVv4}Dm6FpzDfNM>Fm!LHpkNl z><`!BTRHcUFgRx82Qm0eFm3m`SygJV82?ZR(T z)*2CxV)C5EPxSjKuXkTMM;&fzhF`Aa?&<{q)icf9KSUz5ez)z{bC&UZ9v6qaNGa}i z#8+2T6tV*t7%$^E+iv~|`M^i^Q91U8%Rup8jPC%;iA;tL{yYdF6$i*svL8vC)-V@KTEL(PNN#^L>>DmHJn;_l$t+-qtyI~qtuORc55S%X$5Xi zf*+I}M%*@SvT5ZC20r2FS%jw4gh8^nQ8apPjFX4zh6!PlJ8k7Id`d4!#P_{R2*h6f z__%snp8{rt=e=<9t3T!*!ZuXB5FbEL}xxF zuZ?+Zy$zhs+lpiBZQwM2x?}5Y;52^9srv@ch!QjUdSN&ep^kHzDW56gKurS=p<~W*M0#3S=>%`i_yX4aNrUuP?XD)i$!vh zo!|@Vy|q`a!TDf(4LZ6kz>lBcYP|y0Mi2&%=_ulZs?4*~c<;y_HGHQs03|IN*>d(; zvXNwCKwTiGvjJFzFmUQQTW=t2R^aqg$(19^l!=^BYiA=IW?~b}#nCNKQjtT4=?-F1 z|HLIbMM4&I#b1jebv2Cz^kkRJylc^s2X$X&4$38q;V1(KEBE8QIHPCC3ib%In%KiV zKz@2cma_OoT8{aG-nP}*N9T0CITwg!%vKI$dLz9LtEI4tLLOdrBsEd9W}k)A!dhE0 zsP*h%L779-Jcp!n88YpM)wF%Qs5V{mUDNj*eXoty6F+>bP=Lx5WE#Z+z+O}N%+ zALlO%y9+vyvitBeZ(MWc1qP$dLC(2WU*eaVMbZ3aQ+q$FT2Q5&f=~CWX7sm695I{1 zI|L8|a5Bc514wSB>cB2av>KwfrnTkr$*V$NyPq~hvHBKL4gEv0Zr4PrmpV2Pv|{Uv zn}mHxv$e@s4so_NYwP~)Z`EiJpTOrl&zn*a2#@MG^4Q<3EdA|)qvg6oh?eIcLbO~z zX<82KR+))=w-ycq7khej@^Q$%cUr9j4E7uQwl(?sCQ=`o?B)-2O)>s?v>%BH}BHhk0XUS z4-_3{K}B<@LJ|82M5b*<%I;90s9A1)Q|<)iwg-jo^*mDf1~G2IvC-X)$j$Hk6BXy> zFq2=_D|PCU(biW8YGh1Q$g72YLZMy}hGvHlT`NPn_G%L|!fM-sQ7zbT2-w~wle9f( zULZVCs{L$xdqD*Z?^Z5$#!}ZbqOut%5H9A+nPu9g@-t?&93&tZn(am zUF{zDI%dyVF8DLXSog{%54>)#Ja7wA!XbID*U%6Sj=6O-H_|bO$`aVN1eJ$Ax!&;q zNXYeZl#qKXI`7F|WryCy-N(4O%YNM0Q}l{fT^BL3CenN(IpPnCrBotwh0=TFtz1kQ zXa3pW4_8zyi?dh-5W!mn0^m%9xr0h6w_;1I8{JYXCe!NKf!YxELG z-Dmid}*$*!4R3e9!Ky1)b%fw1&qRe-;`Djr;#6!fq>}h_(SZ?GwslN7eQMw3RDIIrgm0UP z-^pWqS!{m^YHXxWmZbP~iXV?DsX+vt%Vo$HY@Ha#tBzRyrc)CSI&xbgTE{DEi!qI# z+s-cPeZoAjCR1nYb`!wz=Mf`;mi=~h5B>J)gG}7`o!MItDs|&{?}JDfW)H@3R-b_8>lMM1 zb5`umRi|1m0tV_f;)*R4^ec4KK@8VMO``4Dp?&fYrFsueZ~Y-j_IQr*(L<8rah&H1 z8JJDx3p_Gfsk!0ZFus2NpOJk^i}4-eSYpO7D}5#AKDZHdV%6B4zoqBp13PZ(F``=; zGMGhI%2w7g8(VUBfE;>Y`Lu-8X0bnD0lx5qF=1cb=q4}Ch|*j3qOtBX;_;ZD5!bD{ zzODC9<}nWyEeU@(p5&GEQhA@y z&{;ZtaF|{fSWWgTZXDNji9|mvGYP*>C0x+J-f9_}$>vlm^yh7Q|GNmDY(OQ9JfY0U z&!bt>Qc?Sg8%1NwqLYApyQN*WAac_s;@ft|EVEQL-3s#)5= zH&*WKL0E)ep zFhA@`_K-3`quJPeDcK3FQ%0av=e*5V23~;gQW;*k4OJ@xPYRu2J>04(3~Ntsn6$+e zxZTP{;=r1W-d7AGc6vrTcP5{{=)jsY zDiZ(vpqZqBz{JqXaomQoA#@xfS17%0;XPn0{Qv%L)FB3G*L1oIXhpxhM)D2!hWWMdwfAVaB{OScX0D_CqLvp`+>d^ieDlE&TZ2b zG{zgS|CVze(}kVI1S1J-f~H2af_}2Z{rPq?gp@?6Ny z4)5Y8!(cn5IaR|+DO$Bt3D?bmum54F4(tCXvP0-lPPZLp5K+{oeIkXx&Y`=D2N~$) z+jtfS-Tt*Wlfio*d=9pgXFH92)5>kXuseU}YBzk%{?o7tGS#KBPO>BX7I6$N?ZB&% zox!!?10f@S$jCt8_5DRG`5)%h?wPf#q8TkqpKg)$u0Fj|HMTpOn!KvayTIfBX z*4e3bvV$KjlW&ggGL#WMeFZwu?bs7=0OPYUOYxgmB9W?v5P&K>w@d*^s47f}W#4?5 zf<6dtBRiLsMyK1f*mA*vfGVF@+>3%l9>7-c7Hy$48!U*p(` z-|Nf!N-d?qV5>Hk*f zE+_cqO!)#`Jg?RNc{H^v>NK5kQfX_i)jFzE==%9-Oc(8G9W%J&@J5Kv*X*#l4gfnV{M&S|A zz*g%l=$qnaqs3d6^i^x^fN`c55?-sd6@^W6VdEQDp2})!T->s8XqiQ1ICkU8`s9q9 z-9|M5<6!P28U`_gX-N2$vFleE`?W}2Pz#<22cu^8$+x&9T$C>i?MWD8l&m>qY{nZnAT<{dA-Z?-4QUcRIlnMnQUtsn4LVEK>)^$+crk_Onag8`iVUep(syAu{Z+)yklh} zz?{d$ni9#3(J3Hkg6r3lIp`8{tUAFEiX^adCsvr!lz{Gxn)uj-sHBJ$&}UcZe4L-8 zjvUWbaWbsZcMa}XAcPW96~`Ij+VfKd-c|iOc)vb$J}Jtm^FRd={-0$BUTf$+0mvXb zk`}RF21`a;d5p5vCV<@xUyV!Y4XGv9T(anAJAlosvi~0Bb-u!CY>)a zd>+Y#Ts%-}QLIBU4_uOFc6y4l z$*2$sNE5&#UW&P^yonin2&)D6zj3yuEF>X z<1#(oM}>k!(VEN-#Ma0hOC#>LutJ+(IcvdM_88!2(jTO*ZL|&CCqW3sOeW;*#aa|_ zzr2n@uDfRqh0ZhbhB=h5TnuAX-njVj&$ixD1G_}f@)9>1#= z$uJMP`PUgc1S;LEg)kr)Z2|vebQ*&Lkyh&H6ieJI1i)!3a7U%&`#va`NVSZyM{8yP z>)neW^AjP^Ab6tKNflcu{(Y)#bN-SI3;mLKa-9W%XgTb15;QI(YqY3v zm5|;SWygD*?D!UBM=+>@iP@d6M=5#~O40u2^-vi6W->KQV)6onB-q`^!Ha^hQ)Srh zK{U>+@HgU2QM_=n9R%qSpQV8-Zz5A1oKdO)x8SYAV9oFoW8qa+UZaC&}*yQ zNc_t9lSL6(sbE=kzW3x?$5yJ6So>cB%fh|>4^HCpX`7$CB=9oj|Q)4?{xLv`-` zC;{rw51AJej=!8Cc##hoy8%I)%8aD3C?DDJNCUaFx8XNXZb+qE?c;B7LP9b$vqwMnjJ@Z?Zm?g$S8b{s>^6H$s-RvrnQn~Q0R*nQnV_zWlq)an07Y8;0_28aF~Z-W4<~jr z{@_(zl*d|C@5Ir#WrU{nycS;!=YoVxcCiL>@s|BmSNK(DR-$fNs`zMPIwsIA#d>rJOE|IKDL=h<#@ae+c2MaB5FMz=ZcK&E}{+{lGAyke+oYEjb1Fm zBGRj4u2&VSN8)iX?7)(sdK7Xj%;mK?2X&-BY3r zgA?32180HNrbfF?3%E$AUCBW$OwdOS-i1SoBzsM4D~m}kX7^CMSb_pG3t0FfVJ6!q z9&@ab@_Vas*K)Z7?&Ogp1#so$V)9(nZ`@7_qIy*vPC%dob1|$GMh{uJlYLk!VUAc5 z`IuLk==u_`=y}z4^x0%7vp6RTK+cG|G4>t?HBhcOkb0*Y4IUL<)e2S}XPpd@)!$Cn_Uob6=)qf47uK|R`X4HD|qH49hLwArJtokb;q2B31C z3@*boG@X5D-pNtAN!cS~S|2ze96E_$gcJ1QE+Phh>tFy>n}Su%SN^sa{H@5mt%N_s zS;ITJNwg@J97M{_3VVJaTQTmqy$Q#=Ib zr?SE%q*tT~kaj#A1^9^&j;Zug8T+<4Lgt27v3|ui%V=J(GtslEOD%uY> z+SvVI&I+>|kGt6oNNga-I0yaU1#Y#0TXLZpE|?{o@L+Rbwq$|aMuuGm z!VEVN!rPrPsBK$zp$s}%8bk;Ck-CBjHQ|vgUe(|d8VOjbbLN@><}}*jx}fIhLKeWK z$;Jl^_*CEEN7!p9t3?Yr!N3k4ZAX{m_at$lCvOpee>=T9qr!=b#C6|3hhC=i$ z)RGaBL2|QX>`Z$YkU;z_fky?p__;u1;3n8AJec1HarVP;{ITKMmq*oN&){ z%h}+YQ6sH}%eZyVT#ICI9P^4h-)t;m$W|-Z;)D=;Wb@sQA7va(jQuuoCA`WE@6H0r zC1m3=U6)ON!(i$HiO7XzbX^8lnQ?|h<*Y^UPM*ct?T|dfmh?Yj-L*8f{}DeaeF=q% zdXBdvZn>l|v%y%5j`Vu4fgCJ(V$PyQ$AU&h_qO;vYyko!ECOH}z8zGo4*W+(VXXd27--UNloHmnE}2OhZEO(R`(-0hq#LSWc(-c($B2XCsY^cAJ? zBX4ti#-wZKJ~DBeY!7FyNUR_0^IAKm)R-;n#3=irUxygt{)RokWgLj$Yj6fE2ozyjF3cq0f2!W94`NfieJKwt! zha9YHLQd0A0$3o&ecEz|s5UrB|Fgr?I9xodMQCxB4n9B>IFJ1RSUVgTsG_e$Yt)Uo z88b-_=gsZFn^;O)U9&6R1RsarOa^f}g<60BvSwEyheZSgLXt6)2k}#=_$^bYZ!-3< zViALgSrNxZ@OF$Xq(`r0uh8*N`HOJs5X0T2L455>V)Vz!Z2qF;Ds-gao-59kB_vg3 zCMpDB-|b2i{I1S=RgMR?o9N&8QVt7U`SR_VnV8)=B zi75BVxR?xQBK#!AZlH;gvX&cvRN?WgjHQ>cJG~51m{uoj0JmYDvIK%;Y;Z#>u>|6k z5X%)5v0o>fzvJsAL0 zb(%SrO?N*rExWi(GDzC>+oq%rLNzC041tS=P)Y?$>!OH&_H;;|=K2tW(X*gfqkEUF zN$Jy?h7%*=y1G5K*^8+!frlx^6zWsN!?aB0?yxBEW{LrK+_Xrg<(BxU?d2~w_Jb%{ zmyG?yo7w362ud{C$BuM^${hMg@Q4;XrjI2|=wrdgU>ZAc76_hCZSLE!hXLLdK0sy` zQKeXm_0E1CRlT~rx{#V8*7gYp9jzIf-Kc3mspoH852}BHM;XZ|MJe=W`sU)lX#j49+ zn0aZQcB2A(CGwlAuuj zoR=yS>?_}n_+P88#g+t>Jv$DX*J*g&p zm>y9gb0lGFu|tLa6`Q`wZDI7IGP0sJC`=|>Mt^JST#=;8^TFzAtwb8kE}@bU(ghwi zmTRegkStct;n>>>nxK=#t}ptHLW3ww)X~}pX;>x0ZSGD(RpR~GWa@D->cvk#+$KIN z!|mo0G8k?y;W~a%Cn%E!SLH7bw>5N;Z9t=4(Y82__vTQxt3pqjykwEEU2Kz|PskHo zRj+NOc$ic!=VK$bU&SAIn-d_gAq0IJd>mVjHAb>;&iX0XZkRk+iAVmoJHVHw8 z-fHZy(HK-TNl34!O9yADbE0 zy<$b3T^ux_IM$+~#8?t@rlF4L$Q*~IWYb%qfvucYQ36-o5$^C}o1xh>ix7k){?IW4VD*T$ELLW$pn3 zz6+%s5MxFI`p7v(;9~+Gh`T{42Q(>4X8kAc%G!B2(V6As1Or9Xo3g{c+hGKSAcl+4IqteXw#_&DFK!w2vK3k zoJmaozFjAp=e8IPx^o~zgUk}Fqm&5`Qx8{&60hA>U@vYjnh(iE$ z8Q_ve#t5Qio~LL!Mleu?cYrvK5#X~K1k#(!Itkc4TU3ASt{5sC+cWHXQCjbMQI4)P z=5P`3+7B=hNp9pb!rKNOy#~kG#q}_@noCH0aJn=|!hr!N3j*jbfh&GNBgAhK13BUl zfrtzr)rc{WYpS3r-D6@C1RhO{<3`_lw>16lPO2v zK34$aR)&!L#RnFuFm83`A-*$D)pxSNL`QSLhe-$xuq@}A5sz45b8?gK1hIq>K6Qde z1uLlQ$Ur`Whbehy_D&h46CTh;mW3qARD5j=O8gc9>d|D$MbIpICH`qv9`#HI z=jOH?bPbrvZgX%oxI?|{F|>Lz%>-zHD!PMHKLKX(&_(uc9gsV4cYHv9iAUk|DBF;? z*kAs;uDC-Zi*a0)`W}4N#U|?EHNm=}7JoTe!VMzio2~j)Le2I=n|L1cXV~SJ(>BDZ zY0_*YiT9rXGPqq=R{K`EGp!4UwZ&cI7qtyliO{J4qU_LM^fj<8Iqs&#M(AI6dQwu& zW*4-e3b1lU>4GinYerfeIB8LjQ#97&Ps+j0*+FQ0j6o&#S!fch$sLLaHtB)xny5rP zkN=~uN`$B`;OI^-;}@;GK}i!SYb0?BNs6I>$*{YFi43n5T>1=h1ePhb=-y>Y9hS+U z9|tKoWk%bT{t?H|V8B=w=*E|sK)2)bDO{lEM=UkPv9MS}q0PgCVA|(wR99V-SNTnE zTr9b+_lY_8_10GQR$k$ERJgJ=&kyjvi}JNYa`Aw^fJ+DkAibbtgN$8^{P2Oqxg;4c zR&63{1sMFmvGIt*^hjhwg`p}adxgc!omxpu6w6vks6gJIaukYp>MaVBZWNO5A;`Fe zXh5xuV?n<+dBsEv3|vBxU$tjV$R%jS&c=Zh^_MOIE)A1>YMTy(ltM`v>f)?Z9?uek zLn=itLn!t=%wCF_{03L%)hi}TuN?(S7UV#J4{KKCfI@bIz-V20_2QTx@Bw01Ihjit z${4x#WZvZjUr6%`aUd5rLffXg)G za_M+*YzfQFU~#fIKD*Yz=96uTw`368C;mWN)N8WY#{{4_0y5xM`-mRi3UHyf0?sjM zN=H`f0(er`qS~66MnPn;gz9T$kycGdEq3tj80X;+CxxfDLlX{`l{t1uAdad03^i$G zgmE4i$4p!Wu91ZcCbOvtz(PGhdFmdc2WzC?me&?*Qf~fhGGo5!^m*OWi;cfvf*t%W zPEBJR`{fARUu2Tc@ejs^Xy-kCYC>qCNx*f!-<10bKrFq+9><%$ZfXLX9M=6!UpE^B9{GfPxa}8rM>&KCuJ(^jt z3FkJ_eXER)`#WRJM~@_8cM>L2=f-c z{#WkBY{WzvkBeejGJa-5?vsh?rRR>)m1b`yo*XIM^3V${8&e1VFq#zCf8zt4YCOk+ zC9-wmeicbDhdYkFu=A~Uk7q9{jI-5J30O7!hYUnSA+lNYBU1ZdjANK`Dy zG2GMXYrCCG$}oNL>fE(}?i2f$D0Rmlf8tH}1Gmbajs{vdl-C<4Dr92sm*Of$ZsHrE zw?)4V57G(*UJ+l3<^)E5Q@RG(T_KTSvGYNx zPCpc@1JhZ9GW3CG@;sP+DI-<2LNTL~d-e1}11Nks}(GAWr3byPsxpyjGw|5fjs#mn z%KZai9E2TZ*wG>dZ~)9-sd>6g2aROb>AF3D9V_LB$soozpa~Jp`4X**uUFYB$b%B- z2)kToz+hfWNfbqXayYVY~3L9+A;kREW>h(@X!ab)8z8AdMgARTzZWvVWoMW@ngF4U6Z7~|d=MT-`Qg7%%1 zL>w^a#yy6j_z+=}S_Y8^$p;Z6pM$*$R&d$cxr~M(8;#hM*#N=B$85~$VFJ!g#?F)h z;+v(+$r5AO!PR6AL|QD*&tw`Bu-$BUwXxrc^cd^N{iY;A8w@$j1UWLW!o$t-o(>O* zyLLX_rY8i)o`EA8r=+@r0)t68+z*}v;Y(m73b7)_rgMKL z9$bmXj%Qh{lffH~&1r>FLKZoiOGv@y65u%%(v?T`^i<_9=$J+rNWwf9xSXiNDw|e} zUgO|Cnt^v>Q7B83NX@SvUVj!>JpZn0`p}Ptg6mavufI==$al7ZGqZrl1 zf)vcr`6jB%Ya6{J_0R59>o{8(wRPwX68m&J_zqd|AR{0*^hQ>ulr@z@J*tJIVvbZ( zoyOs&2KI`_U>&Upss9Z;;9kNRHHiknvY~8G&2tmN8vZ^b@-iP zug)^5zqHqFn(F%kNj=jJyh~u+%%Qi}Ax))j1@=m7?NECK*)zBtEWs9@>>}L&b@*M# zWc(m65SHD^6qpQC_=8tOu>`PF_CA7?poOsz6%o*b??y2ywBXOAI*!MKFkT`%AGV9d z_;RdH%CQYVhzU*TxZdO?zt9JFK(LTo5qsD0tGy4iMKZyOLYb||EM$xo5}e5+MWAnb zhlFd~))kDv8C#<&SR~~sw~95j(XMB6=r|(2dLB5xUob)9Lb^WybKw8K#@mBe6URE6 zO8_!jTfXV8*QCkB^F|vUV=w5sze|(KNKRo!fwzO^5#lv$W5u-}oPz`xhvdE|ysUl= zTaQUcT*Ns8qmDcAFAi`Rz5J4m6Mpjh33Tvsw`Bw-CH;&6Gw=ouC2uQpi5gsW7hWQ3 zgu`KPUEryNcp7f23M!3qBT5*02$)inhlnjCVxwox!d$7p5>+nm1bQZF_EocZ%q@u# z-)O=$OyKk?*dUGZZ31_O0vuKpY? zM6g@3qV)NbUNVD%`RQQljuRlrFxkgwKSZ29mxdYeY@89f+Alk;EVvB@yIkL8fU>;T z^~)x1(}8vn){ci4_Cf1Z9}rLt{fg~H==X5llZ$1GF-5%{N(NP-l2NFtT(a^(JZ{;b zL*ffD)@gG7gB!PWf17k+JT`^x)ktC|M+XjW$c%U5PkB#dlb$13xFeq*NE_aP)pV(hg$}FgWe^ z1Bo7ciK-)!(NOtdNXyt7?|2~e_9j#QqIAk%3~I|?^xpiHb$bUz9s_yKhXyUmQb0LG ztP2j3Yt?uVFead9fj)VgUspA%nz*wQdrokrAAKZ{gr(1lxye*l9$Xewgw7L)Ga%*? zR(v)(lk#H~EFg3BlPEBvW@7BkUm>e=t|5>IKA6f7Uas}?gieH-5_wB#3dlj8@P5GjApo< z3c2ig*ol!pI0KEaQu_v`fywB5Fyjzhwc9k23Htoh4Ul6qB)V&cy6UoS;A*Vw z>-TVIlWgvhnM}}tbk0TNA+ws)h7`N?WP%2!Nqz!_9Jj!>E6N4q#8QOeZptxB(Ml!I zZ*jZcwi$YCZAa8%T(~2`z|hKKVvK-^O;pMtb#{{sS^QMB#46-@oPAuTiy?ixen|Pr z4z+4OF@y*N{9-cOAVFa=gDqY%-!T{2=s-@!qxqim(`kzDb20`5 zO!0m2dt!=w@uuiO(3q-y3^{BSOBS}_v3T3S?@_ja>dQ@MPA!E#x(s$kZf=Im5}V;R zm^$VFuxf_cA#6c&lTMDIjvKh=fy`~g)LMJ?DcQ$-mOH9Q?+M&h&JcV-O#SKniB|A2 zH_nR@AZpj+wP5>&3gb)4z?9qP*e#V9tHcOaJ#z#`5`!dmT#6A1S2UMYjOa11YD&+D z5nE=TGXf*lhKNy)=*SKANO)dzNyUiUV_wjdK9d-+k@wF>VC+(iU2qFZBNA?EE~yyN z+*_$5A8!cm?2#*AWi_20}-WLj`6@cwpzzJqUPNwT~l*!({=H0drW9DB~u8 zs50_pBo^?sYQK*hyeJl^igq2oBCxn>w*mw&3c_PmyaTjo5w|GYp92Ih3c}c|2?Xq} z+8qGlBAt+n@2E6`fb&)R8-UBrAafF0wH@Mqf#5F=wMrYeh@C=R&q|yQko0WtCd(`L)q0zJ<)PV<)(B)t_fCo<_`tg^` zqz~X&fe~f%(Mu(gnW%XtA5JtZiO3(Rz7lMAmi#sJn>%koB1mNpCDg;-A`<0@NhCN zcG?0r^#EOLHJeo;O0o?UzOGxyWArq%eDEu3+*D0(wDg{ zaT7sA`f|*=voGnY!`L`*;o^&~q|tyaPSDWVadd?#U{!lQwVk3Qu~SPWAx>|gOeRu4 zbYq;4D@67v*SxZIdyRSs-)%Sx7g9&$73$?mu!_|)?iUHR@X5W16C&N%_zG~N=UKc_ ze{eTGf%f~z{y28`EbB%hLCv*E`LbW9+XIc8?%S`#_ZcGl^GKha*CMjRW&%6-t>{`@ z0*klp9oP0@fE(F?bw9(OGIkw6F{}+Q!v?z;glOLk8ryoK=L$qSA&}*k6!^LzMQ1XC2RQ2r zHq4MU2eFVieQR5s=)%C>3;GR-7c@R8;ncH9(72g_`x2(f#}M&V0I<`E-8ix1-ggx{ zzTf7=ZoJrWi-;3D_Dy-QBe4)W-o4n1MM3rlU>#3h9?p>g@A`QA2mkfapPA=Te|iUo z9{Rv*k9F^xfApo_#5dSZXi)FK#z%*azk!N{62E-lV?RFf2HPbW!(adPiuc7gh$bTM zksS{{`kjw?bOS5?@WCJdWcm%5Y15)Z-`==w}P(kZf6(D2iob# zq;?+3DIBk!m*f$ZV}yPZx>QYq7pkeBS{R|4k$iO_R87z}hHCN}^FlMF@{yW}Q^L^9 zHV}Xq4PTYuV*tgHJXu!fA~iHqPPY<5H4~OV2xPf~uY84Ojucabb(1E=Y)k)q5`Gi9 zbqV%QwD=}Xgow#b9p&C0cHzZ@ber zY#8vVhF1y=uXqiw6dGPBH5`eBhU499IE^~TccG*sqLO2n1OW%^{UP#KbY2Sf>0&2`4NnAK@S?0Wu_JP>?^?SL^ zkKs(bHv5C|ff4NwX>GV)4?O3l0{r4oR_17speM^2VsYHb-I0h&e#ogk_Zw5a_-*5Q zEECyk{-aKwBbh6SFdS??l#dsxZ|B-^cnaPV?|0F%64ZrcEl#%*7DxYt*?jr~8`a@S zny7a-209#QmEyp~Iqtx_qXFT9+u}{Wmcx*|eRLG}8NH5Y45`R~4@g=Knc{i;zq=Em z)701?sEbImKW4{PaLIE#gr z>ezQ|=_UI|df+a$t)u-AlkP+Jf>BeE$em`wiw;!O&VsO!Mn?N%c@Er)PTK z4J6)gaqy31odfW6(r(G~(853I=|rZZle_hf&m;5M%R96$n_xl(LE;RKY)AMQ3U*L{mD`(^zIM{%mw7{=YkVVRUoUAKihsg;9>TyYYXH zoSUP?(QVQE$ZpcITRPJdSvJStGUVS8-4dM!n11|w2mXCwbXT+_Iu&nAP$rf7wxsD( zS*8bnR|5a7!1oehxI4NRaD2W9|1L&d3$?CQHEGGiwR9HC%@|de!@m`9XwUXqdOYEd z8wGb7@ZSkaUgRlS-Ibczk$t2qol*rf|4d{bLn`oW>?-Lj+twewG`a^A-zvNyl`r+! zb}P1(Q%h`+!|JJ8N05r0wU24)#vruQJT7PT8S5mxO$r64N^ORS5r3z zsa4?B)a^m)6yVj=m05|m6L>Sl8>C_f!DE`bF-WZeucmGfQlYxLkqQ%8IXyk!fTPql zSWc96MA7N^dk+5Y!QUYM*5hw8{&wOo1N%?M-*fPH4~X70UBtd+dU^zM#YP5^#XqOO zyA@*PVd)VR_*DE|8C?@SA8LFR-kurRwTDS#HXN2tBLs>@*WqHy=SI&4e$Cqw|f0stjaIjZ` zamWXzjfa<*u0m-G>TU#$SL6R1qjS(AyF(#&9iGl1rkVJ=4z*p2+Aa-XuaBONT4xB> zM`mDk8gR#q33~=`+f53+WslHjMo)wI6nf9NXMs0YlZ%^>hqiAy zB0Y*!(#!cgw*4APXt%L|hS@KLSm zxjqs;J*F@lTf$taFgp}xS4)`dBjMocnJS%`t?If`VKynumXH0&eyiTipZ-g#@ z`@6Nw%30}2q_Q!B%F$(19<#Kj371m+)lw^GPqZ#=)of||#@VITmpbO@^V(~7DDb3{4+IzIy**R~;uM z9zJgD67(QJiA`E!%a|oD7m9)stLA7ObH=LU@{v?+(h^(7ETQeVE@(%tb>w5!ag|UN zl-Q&twv1Uq+YyvlRo6P|W7VPU2uf^133{=5X@ytAD?eXop>Mt%`mI=3HcFj)hV&8F z2v@EH6lK;6ulGE7b?5OPYX~hHCtOPPTT89%F2gqRg*^&w?s8zi0l(Qtjjpj`Bj{4L=2c+FxENz3rZA?$MejU0Ul#X~_R`i~07@>E{^Uk_ zo3+Oa^oHZpZc;j1yiIFp@iSW$etQ64aXeleMOk%l3IsHL8!U zr-XWW1?s0q8b!rp3caxt?TsW zx<+%TsniaXf`{F8dTH;^Kork@j(T;2{L9gbU44e~^o&-J*MyLp6mrWMr5=vty80T0 zTlusSZlt~n+}fu}%^RM!C%qErtqQ%pC3MI=fnIf{;C}ebX56E>CeV*5^u{yytXBfR z1MrCHcAeQQld$=`sv!Lr;iVbC}5L9ZW$BON8EO|Lasb-ESx^3 zwQJ8){W!1GkFY=0xdlIFA$Qr&*c~W^-ecE!W$)pwQoPQp^Ckb`^UM6}(0lYkK9avy z^EU+f-dZJp6Y?1^pI^qyj7;fAIGzxg-3qhvg3&Panp)2Vf@ebj!zhdMB?X?X3bVZh zOo3O5cvpXEruCbv&>*_CQ-H+f|%#}9x?{<@e+0q(@ zJ-glQU{*dJ(ByqTBRi4JTI32R$AS_o+3KLSw}LA4Vbzx%*YGU3;A<@G@-YXs5znH1 zWn3+D!aE2<$A@PzSL@?ufmrnwg?JdxV!rqV&?!RMwJvu9o`uFC9>VC;ZgP2B@SIMq z!sRcFm5?X0-{JCiHJ7DFwyVDCYQ-}s%RDK&mig36JPW-k7bLhO)3gk+)xmGavl#z! zp=Bu+E4V~+E0$O8#1aOVSNfydLBU4UfDZRzJWnC@C*ZGD4Yy#4=0*5_K5F!fI zJPZ7X0l!P%5T+jv{4RYwH0)CgiB}|9L?{Mk6!t`T-|Ccj+6#^lspH>083|9^iNByTbJ2f&beMKb{5t z6M)~PZwS**1b&ykB}|_S{4RZ0n0^xQZ+7_cEbu=C_+9#jF#V~(@6xw~>9E`#E`3*+ zehTn^2l#1scos{d&xUoq6c&0b7DDG^u`-99-YpBGTqeB(DgCI4C4qShp2Z4PX|Z>~ z*6#5Zx|^`~Azb)wl+LGh|6lxF53Iz;rOX!sBNsID=tQL63*T@j-f)tmsQG5px&(FK zCZz~@H*7hFC%74@^d(HAg_AmPZa3;OSE0`DMd{hB^HlsPmibr`z6E7oiY4N^Q1ULp z_0s4R&~mdZ_Lo4R(@vu=$K#6cnxp(IJ3BQ!&^SiQ{0Z> zT_0x+zw&eAN5}k(JL`rwe4Hn{>xQ>{{L}Co-t}>wH&=dP{OFjUK2kTl;p2=Q)(vm@ zIOBzm;awl+iE^cF{OFjUr?7Ry8$Qllc-`=pk2B8c7~b`9#*md?8b3PbXJ%hFyy4@F zU)K$9`8dz!JBD|C{9gEfW&G%vpRrZl@P?1y2fyJhA7_l(F}&;J_rw2d<44E*pNHS@ zhL1l0zu_$({{sAmcYU07h{~q%qhtO8{DwDtd;)&MTR#3E{DyaZ{5br-fuC#sB03(| z<>N6`(%l=9?uuIED*PBT2w70WCi-q&g^wcla+RIuI(`C~(SI4r*!B#+_in(6uEq;& zPUarZ72Dq!BwMbseVh^N zs^Lu^KLNktfsa1~zv1QId;BNiC++xs{1p6#H+_5-e!~MFpM&4<@*h0@)9{ma{61cU z-|(i7KMcR&fsfC_Z+Q8S9{&RTq#eJHGd@@~yy@d-;5R(*@kih{y!?*Ge-?hyj^D>0 zh2QX|j}vii!vi1x68wgj1CRg9@RN4@KK?lThBtluEASg0`1n`hH@y5OkN<1%lXm<* zUV`87rjLIee!~MF{|5Yqm;dbXe-nPvj^D?hfZy<@kADk(!vi1xHvEQ{|KjmK2|sDa z@8f0o4R8ARQ}7!e`1sTC8(!{s{LjEo+VT5%1%AVuKK?BHh6g_W9Q=lt|LXBS4?k(g z@8ebY4R8AR3-B8r`1p(P8(#jK$Nv)iq#eJHzYM?OO&@;+e!~MFe-(bi%YXOyUxS~t z?&+ZtOx$5M$z0ZCp&N*6gE*%z+4IG6Hnjj-!# zlx=m$I1<_K)tgtJ|Cpawdqhjf=CxFe4FE}G3@IQbWC=W z5x=Zmzg6akD3gVWBr=8+kP@_*6QV>4 zJ&p{p;W34bBSrkKB1w*qAw{q%vVs&yZ=ko30nYsv`3B%lA>&Bo?|C)tH-;3D60(G> zA$#+W^%#F8{8>WQkWEC>z$7w;r0{PXDIx{ZC1eR%LpBknhlwOo<@gG+fh1_FBr+!9 zSOF;^McSx}tWe(#q)1(>$O^K76v$sfmL%j~LpG5F)5FR?=;9hyp+BIFlmo~XCsCr# z`wrb*c^HN?(F5w#mm&ZA?{;@q4@oVe1X6gF%h&!S(=iCf`9xJUH zgd4;)Ld;kG71m=Bol!Y-6S%Z);LrHAE^#7py<-Z?nuYWpZ)@^Z|J;xtx|1 zjxXiy#1$unO(NO~e>dOrt_Cw)5U+(_tu_gwZR{#*2ETUv-Rq@%{bJ%Q->OlPC!ey? zM))L8nOGs%rbMj^mH)HvdaSm|Yt`k5tFKm5y!F^sY+R_K(2FW5hmm|%0ntW;UrOB5jpSI?t$(JTyntWnWjzRa)vi>kKf{Y>= zB#Y!+Nn%lsA@>>PdjuIpGDsH5Id4>wSd?SfeMb1!gM|!|MRLw#d83lVq8uacGs<@c z$s#$dR5N)kk5rnNMi6~6NEXTQOSMZ7Z?%wWubRngd8E?Bq+I&s z_=K&f7Eg9Y7VLycZ5cWgZ z4`Dxqy`r+0I2gu$82e%Dhp`{Vei(a2bT9ESg8c~gBiN5%KZ5-T_Pxf~q-Xu+L$i!#;<- zqDqmWv#T?tR#r=?w(?k|%5uVe9^_k#zj`NT3YmscQK`sMbm$E0EUBf{TB@`_l z>vJ5LM5d5wQi^Crr6Nnwp);(rq?T4|smAhJCCgf$Nkq%p)BI9zP(&*#6Bf!^(6HM zMYN()k)`O+8P-`+ORKe1V|lHTWu31))#sLO7SVU=s&E^kKCSDgu64RD=^CQ;lkc*d z;f8)9@lfIL^;m-Gct`Bq^1A5wA-I-;@|CB>8muH(F<<+W3-%j50bn^DTZmR#CFWM>l>@EXRI)E?8YIvQ3u(V zwq&$RTHuvAL#Gz{2DK5RUiV-_!zJBLqX!dvZ^;@sopd+wNw)x&uT?^(WpqwVj2YqB zJ9sJ5mZxcD-R@@@#OQITZp4$(@TDUjwX1X=6?_)WjeHTk&wFx;K0O|N1ePhzPW0eI zR;m~JMtQ?5Y2SKjxD(y}weUAbBxoSGv$U75Jr{bgjE-NuIJaie0P=X`LtA$E5TN5> z=^e0Z0H%^Oa8$f$==B(A_^3)PK27Q{_#OOKpKx(ie;&R=40F-(V|<pglCq`gYTME@aru?Lowe>fYzoa;yw;dmO&fU=dJ(;UjLq=zW)W?%(3$}{4%lOO zxZnayFZPE1sy#!WXWUV>wr)5{A=$4(zsB5gMV{hr$hHIJrF;MoaS`woCZyfSx&E$ zQ;pg{U*K`JPGHyox>IP9=QZiJIPkLkX6R*2T3%av)zVE%w=Er5dRtmv*Dm1ouDe>D zoC??mI(}v6+<=XyOzpyN#r$6ULHV@=&V6(&s9+h!Y}puEP=YzVfE~>hu zMHd@&P_>^%h6{Et!BWgkbi5I5oEI9crfoYOpyLg6+>mJ#%dxE-iqW_G{LPy@B&OBw z*~wSuxJqiE<2t-Wgb2sJg^qisHo~dZ?}Fju=ufd7?~b@cV=8~&JBw=ld=2Eod&d&* zr%ei<;fuej=`jr@$*jg}q2nEJ=XRCd13IMvc(cx%&D zRDE5`kXksL{6v{)iz+|fdl2R%Y?pGdzfX&a z`4#X!v7(RYm<%ILGENJV=y*SsRiXK==s^w+ESx?we|+lLM6q~cZswl5j=t~kk@=}p SQxgkQhtEzd%pRVdDE=Q9#3Y^o literal 93361 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 I=Ge^t0d}!nbN~PV diff --git a/build/release.wasm.map b/build/release.wasm.map index 16de3d7..288186d 100644 --- a/build/release.wasm.map +++ b/build/release.wasm.map @@ -1 +1 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/api.ts","assembly/index.ts","~lib/number.ts","~lib/string.ts","~lib/memory.ts","assembly/api-generic.ts","assembly/gas.ts","assembly/program-build.ts","~lib/dataview.ts","~lib/function.ts"],"names":[],"mappings":"w/CG4JW,EAAT,E,GA/DiD,EAAxC,CAgET,EACA,EAAO,EAAQ,EAAR,C,EACa,E,GAxDc,EAAzB,CAwDyB,EAAd,CAAP,E,cACK,EAA0B,EAA1B,CAAhB,EACO,E,GApEwC,EAAxC,CAoEP,E,SApCW,E,GAhCoC,EAAxC,CAgCP,EACI,CAAJ,EACoB,E,GAAA,CAAqB,EAA0B,IAA1B,CAArB,C,CAAP,E,cACX,EAES,E,GAAX,E,CACW,E,cACX,EAAY,E,GACZ,EAAY,EAnCmC,E,GAAqB,EAArB,CAA1B,C,SAiDjB,EAAQ,EAAR,CAAJ,EAAgC,E,MAAP,E,cAAA,EAAP,GAClB,IACY,E,EAAS,E,GA/BrB,EAEe,EAAR,G,GAAsC,EOrG/C,IACS,GAAL,CAAJ,EAAyC,G,WACS,EAAK,EAAL,CAAtB,IAArB,C,GPmGgD,EAAnB,E,EAkBvB,E,GAAX,EACA,EAU+C,EAAL,CAAc,EA7BjD,EA6Bc,CAVA,G,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,MAoLT,EAAD,CAAJ,E,EAGiB,EAFY,EAAM,EAAzB,CAAV,E,GA5NkC,EAAzB,CA8NL,CAAJ,EACE,IACE,E,GAAF,G,MF7Dc,E,GAAhB,EAC8B,EAAZ,C,CAAP,E,cACA,EAAY,EAAZ,CAAX,EAC0B,EAAR,CAAP,E,cAIP,EAAO,GAAP,CAAJ,EAEa,EAAQ,EAAd,EAIA,E,MADiB,E,SAAJ,CAAlB,EACW,CAAN,CAAL,EAEM,E,CAAN,EADY,EAAgB,EAAK,EAAL,CAAhB,CAAkC,EAAzC,EAG2B,EAAK,EAAL,CAAhB,EAAK,EAAL,E,CAAP,E,cAIA,E,GAAX,EADW,E,GAAX,EAEA,EAAU,EAAY,E,IAClB,EAAJ,EAAU,EAAY,E,IAGlB,EAAiB,EAAM,EAhIU,EAAN,CAgIA,EAhID,CAAgC,EAAjC,CAA3B,GADK,GAiIH,CAAJ,EAvHE,EAwHsB,EAzHxB,GA4HO,EAAD,CAAJ,EACoB,EAAM,EAxJO,EAAN,CAA3B,GADK,G,EA0J6B,EAAP,C,CAAT,EAhJlB,EAgJkB,EAjJpB,GAoJS,EAAD,CAAJ,EAAY,I,KAAqB,EAAP,C,aArGZ,E,CAAP,E,cACK,E,GAAhB,EAC8B,EAAZ,C,CAAP,E,cAEU,EA5G+B,EAA3B,CAA6C,E,GAAe,EAAf,CAA/D,CA4GP,E,GACA,EAGgB,EAAZ,CAAJ,EACc,EAAM,EAAlB,EACA,EAA2B,EAAY,EAAZ,CAA8B,EAAY,EAAZ,CAA9B,CAAZ,E,GACE,EAnHiC,EAA3B,CAA6C,E,GAAe,EAAf,CAA/D,CAmHL,E,GACA,GAKE,EAAY,EAAZ,CAAJ,EACyB,EAhIqB,EAA3B,CAAZ,GAgIL,E,GACA,EAC6B,EAAX,C,CAAP,E,cACC,EAAM,EAAlB,EACA,EAC2B,EAAW,EAAX,CAA6B,EAAY,EAAZ,CAA7B,CAAZ,E,IAIjB,EAAe,EAAY,EAAZ,C,GAIJ,EAAY,EAAZ,CAAX,EAC0B,EAAR,CAAP,E,cAC2D,EAApD,EAA2B,EAA3B,CAA4C,EAA5C,EAAP,E,cAGE,EAA2B,EAA3B,CAA4C,EAAzD,GAII,EAAO,GAAP,CAAJ,EAEa,EAAQ,EAAd,EAIA,E,MADiB,E,SAAJ,CAAlB,EACW,CAAN,CAAL,EAEM,E,CAAN,EADY,EAAgB,EAAK,EAAL,CAAhB,CAAkC,EAAzC,EAG2B,EAAK,EAAL,CAAhB,EAAK,EAAL,E,CAAP,E,cAGQ,EAAM,EAzFY,EAAN,CAyFF,EAzFC,CAAgC,EAAjC,CAA3B,CADK,GA0FP,EACA,E,KACA,EAAa,E,GACT,EAAJ,EAAU,EAAY,E,IACd,EAAM,EApFuB,EAAN,CAoFb,EApFY,CAAgC,EAAjC,CAA3B,CAoFoB,EArFtB,GAwFA,I,GAAe,EAAK,EAAL,C,IACT,EAAM,EA3GuB,EAAN,CAA3B,GATA,EADK,GAqH4B,EAAK,EAAL,CAAnB,CA5GhB,G,MAoOgC,E,EAAd,EAAP,E,cACD,E,EAAA,CAAoC,EAArC,CAAiD,EAAlD,CAAR,EAGmB,EA3MZ,IA2MP,EAEA,EAC6B,EAA0B,EAA1B,CAAT,GAAP,E,cAIiB,EAAxB,EAAQ,EAAR,IAAJ,EAEa,E,GAAX,E,EADA,IAQc,EAA0B,GAA1B,CAAT,GADS,E,iBApBR,CAGH,E,CAsBU,EAAN,CAAX,EACW,EAAP,CAAJ,E,EAOA,EAAiC,EAAW,EAAX,CAFlB,EAAO,EAAP,CAAf,EAEyB,EAAX,E,GACd,E,KACA,E,KAGyB,EAAQ,EAAR,CAAyB,EAA3C,CAAP,E,KAEQ,EAAM,EArOd,IAuOY,EAAM,EAAlB,E,MA8CkB,EAAlB,EACkB,EACd,GAAyC,EAAc,EAAd,CAAZ,EAAyC,EAAzC,E,GAAjC,EAA6E,EAClE,IACE,E,GACL,IAAM,EA1Rd,G,EA2RwB,EAAK,EAAL,C,EACV,EAjUqB,EAAN,CAiUrB,IAjUN,CAiUgB,EAlUlB,GAmUqB,EAAd,E,EAAiB,EAAK,EAAL,C,EACN,EAhTmB,EAAN,CAgTT,EAhTQ,CAAgC,EAAjC,CAgTjB,IAhTV,CAgTwB,EAjT1B,GAgTwC,E,GAAF,E,IAFE,E,GAAF,E,IAY1B,IANG,I,EAMa,CAAsB,EAAtB,C,EAErB,IAAP,E,MEnTA,E,MAAQ,E,OAEI,EAAR,EACa,EAAb,EACA,EACO,EAAP,EACO,EAAP,EAGiB,EAAL,CAAZ,EACM,E,GAlGuC,EAAxC,CAkGL,EACA,EAAO,EAAO,EAAP,C,EACE,EAAP,EACiB,EAAb,E,KA3FwB,EAAzB,CA2FC,CAAJ,EACE,E,EAvFqC,EAArB,CAuFJ,EAvFG,C,GAwFF,EAAb,EACgB,EAAyB,EAAzB,CAAhB,EACO,EAAP,EAEI,E,GA3GqC,EAAxC,CA2GH,E,IAEW,EAAb,EACA,EAEW,EADL,E,GA/GuC,EAAxC,CAgHD,CAAJ,EAtCM,EAAV,EACA,EAAO,EAAM,IAAN,C,EACe,EAAZ,GAAR,EACA,EAAO,E,CAAP,E,IAqCU,E,GAlHqC,EAAxC,CAkHH,EACA,EAAO,EAAO,EAAP,C,EACY,EAAb,E,KA1GsB,EAAzB,CA0GG,CAAJ,EACE,E,EAtGmC,EAArB,CAsGF,EAtGC,C,GAuGG,EAAyB,EAAzB,CAAhB,GAEI,E,GAxHmC,EAAxC,CAwHD,E,IAES,EAAX,EACY,EAAZ,EACU,EAAV,EACQ,EAAR,EACO,E,GA9HoC,EAAxC,CA8HH,EACQ,EAAR,GAEK,EAAP,EAGM,EAAN,EACW,EAAP,CAAJ,EACS,E,KAtIoC,EAAxC,CAsIH,EACoC,EAAL,C,EA7HH,EAAzB,CA6He,CAAP,E,cACN,EAckB,IAAzB,CAAJ,EACE,EAAoB,E,GACpB,EAAW,E,IAEX,EAAS,E,GAtI8B,EAAd,CAAlB,G,CAsIP,EAIO,EAAyB,EAAzB,CFiVL,EAAM,IAAN,C,EACC,EAAD,CAAJ,EAAW,GACD,EAAqB,EA9BK,EAAxB,CAAZ,EAEgB,EAAM,EAAN,C,EAAd,K,GACE,E,GAAe,EAAf,EAFJ,E,cAIO,EAXQ,E,GAAe,EAAf,C,GACG,EAAlB,IErUa,EAAP,EAEF,EAAwB,E,GACxB,EAAe,E,GACP,EAAR,G,QF0FA,EAAO,GAAP,CAAJ,EAEa,EAAQ,EAAd,CAAL,GAbK,EAAO,MAAP,GACH,EAAQ,EAAM,EAAsB,EAAX,CAAX,CAAN,CAAR,CAA8C,EAA9C,CAcF,G,EACK,EAdH,EAc6B,CAA1B,CAAL,EACiC,EAAL,CAAhB,CAAkC,EAAzC,CAAL,EACA,EAAM,E,CAAN,GAEgC,EAAK,EAAL,CAAhB,EAAK,EAAL,E,CAAP,E,cAGO,EAAM,EA/LW,EAAN,CAA3B,CADK,GAgMwB,EAAM,EAAN,CAAnB,CAAZ,EAEA,EAYiB,EAAmB,EAAT,CAAJ,EA1Lc,EAAN,CAAD,CAAgC,EAAjC,CAA3B,CADK,IAiLO,E,GAAc,EAAO,EAAK,EAAL,CAAP,CAAd,CAAZ,EACA,EAIgB,EADE,EAAX,CAAL,EAvM+B,EAAN,CAA3B,CADK,GAyMH,E,CACW,E,cACI,EAAmB,EAAT,CAAJ,EAvLY,EAAN,CAAD,CAAgC,EAAjC,CAA3B,CADK,I,UAySH,EAAO,MAAP,CAAJ,EAA0C,G,YAkClB,EAzCjB,EAAQ,EAAR,GACH,GACE,E,EAAA,CAAmC,EAApC,CAAgD,EAAjD,EAsCJ,EACY,EAAZ,EACI,CAAJ,EAxDkB,EAAlB,EALI,EAAQ,GAAR,CAAJ,EAzHO,EAAO,MAAP,GACH,EAAQ,EAAM,EAAsB,EAAX,CAAX,CAAN,CAAR,CAA8C,EAA9C,EACA,I,GA6HI,EAAiG,EAlQlG,IAiQP,EACuD,EAAtB,CAA4B,EAA7B,CAAN,CAAlB,CACkB,CAAO,IAAP,CAAiB,IAAlB,CAA+B,EAAtC,CAAlB,E,KACkB,CACd,EAA2B,EAA3B,CAAJ,EACkB,EAAZ,EAA2B,EAA3B,CAAJ,EAAkC,GAG1B,EAAM,EAAsB,EAAtB,CADC,EACyB,CAAmB,EAAnB,C,EAkDF,EAAM,EAApC,EAAR,E,CACW,E,eAEoC,EAA9B,E,GAAe,EAAf,CAAD,CAAP,E,cACC,EAAM,EAAlB,EA9IgB,E,GAAhB,EACqB,EAAO,EAAP,CAAyB,EAA1B,CAAT,E,cAGM,EAAY,EAAZ,CAA0B,EAA3B,CAAhB,EACiB,EAAb,CAAJ,EACE,EAAe,EAAQ,EAAY,EAAZ,CAAR,C,GAEe,EAA2B,EAA3B,CAA4C,EAA9D,CAAZ,EACgB,EAAY,EAAZ,CAA8B,EAA/B,C,GACH,EAAM,EAAlB,GAIA,EAAe,EAAY,EAAZ,C,GACN,EAtRyC,EAA3B,CAA6C,E,GAAe,EAAf,CAA/D,K,GAsRqB,E,KAkIrB,E,MEpPH,EAAQ,MAAR,CAAJ,EAA4C,G,YACxC,EAAS,EAAT,CAAJ,E,EA2IoB,GAApB,EACA,EACE,EAAU,E,CAAV,EACI,GAAJ,E,EAEsB,C,GAAA,CAA0B,G,CAAlC,CAAyC,GAAzC,CAAZ,EAEA,GAEK,EAAS,EAAT,C,GAEG,EAA4B,EAAQ,EAAR,CAAoB,GAA1B,CAAd,GAAR,CAAZ,IFgKK,EAAD,CAAJ,EAAW,GAC4B,EEtTgB,EAAlB,GFsT9B,EEtTP,EACW,E,GACX,EAAa,E,GACF,EA/HE,E,GAAX,EA+HF,EA9HuB,EA8HD,EA9HC,C,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,GA4Hd,EAAS,E,GAzJgC,EAAd,CAAlB,G,CAyJT,EACU,EAAyB,EAAzB,CAAV,EAEiB,EAAG,EAApB,GACO,E,GC9MY,EAAG,EAAG,EAAG,EAAnB,E,KDqOJ,EAAD,CAAJ,EAAe,EACG,E,CAAP,E,cAEQ,EADY,EAAW,EAA9B,CAAZ,E,GAhMkC,EAAzB,CAiML,CAAJ,EACkC,EAAY,EAA/B,CAAb,E,GAlMgC,EAAzB,CAmMP,EACwB,EAAL,CAAf,CAAJ,EAKI,EAGA,EANE,EAAJ,CAME,GAEqC,EAAS,EAAT,CAA9B,EAAe,EAAf,EAAJ,EAEL,O,KFoQC,EAAD,CAAJ,EAAW,GAC4B,EAAM,EAAtC,EAA+C,EAA/C,C,EcvjBU,E,KACC,E,KACP,E,KACc,E,KAKb,E,GACZ,EAAS,E,GACT,EAAQ,E,GACR,EAAkB,E,GACX,E,4CMaG,E,OACV,E,KAAY,E,KACZ,E,KAAW,E,UACJ,E,GAkBA,E,MdqIP,EAAO,EAAO,IAAP,C,EAGG,EAAM,IAAN,CAAR,EADQ,EAAM,IAAN,CAER,EASW,EADX,EAAU,E,CAAV,EAC+B,EAAV,CAAV,CAPF,EAAI,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAFL,EAAI,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAG2C,EAAX,CAAX,CAAnC,G,IAGE,EAAO,GAAP,CAAJ,EAMa,EAFX,EAAU,E,CAAV,EAE+B,EAAV,CAAV,CAJF,EAAM,GAAN,CAGqC,EAAb,CAAV,KAAV,GACb,GALS,EAAM,GAAN,CAET,G,EAMS,EAAP,CAAJ,EAGa,EAFX,EAAU,EAEW,CAAU,EAAV,CAAV,CADsB,EAAc,EAAd,CAAV,KAAV,GACb,IAIW,EAFX,EAAU,EAEW,CAAU,EAAV,CAAV,CADe,EAAd,GACZ,I,QAgHS,CAAX,EACK,EAAS,EAAQ,EAAR,CAAT,CAAL,EASE,EAGa,EAFX,E,GAAA,EAE+B,EAAV,CAAV,CAA+C,EADlD,EAAM,EAAN,CAAR,EACoE,EAAJ,C,CAAZ,CAAyB,EAAzB,CAAP,KAAV,GAAnC,GACM,E,OAZY,EAAJ,CAAa,E,CAAjB,CAAZ,EACW,EAAO,EAAP,CAAX,EACA,EAEa,EADX,E,GAAA,EAC+B,EAAV,CAAV,CAA+C,EAAM,E,CAAZ,CAAqB,EAArB,CAAP,KAAV,GAAnC,GACA,EAAQ,E,CAAR,E,sDAuCC,EAAD,CAAJ,E,OAAmB,I,EAAP,G,IAGO,EAAD,C,EADN,EAAU,EAAV,CAAiB,EAAlB,CAAX,EACA,CAAU,EApPE,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,GAVX,EAyP8C,EAAZ,CAAiB,EAAlB,CAAwB,EAAjD,E,KACU,EAAyB,EAAzB,CAA+B,EAAO,EA5FjD,EAuGH,EAAJ,EAAqB,EAAwB,EAAnC,I,gBA7KV,EAAO,EAAO,KAAP,C,EAiBM,EADX,EAAU,E,CAAV,EAC+B,EAAV,CAAV,CAfK,EADR,EAAM,KAAN,CAAR,EAC0B,KAAJ,C,CAAd,CAAR,EAIY,IAAJ,CAAR,EAIa,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAFL,EAAI,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAG2C,EAAX,CAAX,CAAnC,GAMW,EADX,EAAU,E,CAAV,EAC+B,EAAV,CAAV,CAlBH,EAAI,IAAJ,CAAR,EAGa,GAAJ,CAWuC,EAAb,CAAV,KAAf,GAVD,EAAI,GAAJ,CAWuC,EAAb,CAAV,KAAf,GAG+C,EAAX,CAAX,CAAnC,G,IAGa,E,EAAQ,CAAU,EAAjC,E,MAyiBW,EAAX,EAeQ,EAAQ,EAAR,CADC,EAEQ,EAAQ,E,EAAA,CAAnB,GACO,EAAP,EAUA,EAAc,MAAd,CADC,E,EAES,CAvrBZ,EAAQ,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,G,EA+qBS,EAAM,EAAO,EA3hB1B,GA+hBa,EAAM,EAFV,EAzqBJ,SAAR,CAAJ,EACM,EAAQ,OAAR,CAAJ,EACkB,EAAS,OAAb,CAAL,GAAsC,EAAS,MAAb,CAAlC,EAES,EAAS,QAAb,CAAL,GAAyC,EAAS,QAAb,CAArC,GAGL,EAAQ,UAAR,CAAJ,EACkB,EAAS,SAAb,CAAL,IAES,EAAS,WAAb,CAAL,GAA8C,EAAS,UAAb,CAA1C,GAgqBP,EA1gBG,GA8gBO,E,KJvfV,EAAJ,EAC+B,EAAM,EAAzB,CAAV,E,GAxOgC,EAAzB,CAyOU,EAAb,CAAJ,EACkB,I,YAElB,IACW,EA1MA,E,GAAX,EACA,EAAqB,EAA0B,EAA1B,C,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,IAwMP,E,KAMF,EAAD,CAAJ,EAAU,EACmB,EAAM,EAAzB,CAAV,E,GAtPkC,EAAzB,CAuPQ,EAAb,CAAJ,EACkB,I,YAEd,EAAS,EAAT,CAAJ,EAIE,KAEA,IACW,EA9NA,E,GAAX,EA8NA,EA7NqB,EA6NC,EA7ND,C,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,OAkOV,EAAQ,EAAR,CAAJ,EAEE,EAAO,E,aAIT,EAAO,E,WACa,C,GAAA,CAA0B,G,CAAlC,CAAyC,GAAzC,CAAZ,E,yDgD5VE,E,KAAW,E,sEAQX,E,KAAW,E,UAAW,EAAX,C,KACJ,E,QAAW,EAAX,C,qEALA,E,kPtB0MmB,E,QAA1B,E,EACgC,E,QAAhC,EAEE,E,EACuB,E,GAAb,E,KAAkC,EAA5B,CAAN,CAAV,EACA,EAAa,EAAN,G,EACO,E,GACa,EAAnB,CAAF,CAAJ,EAQgC,EAGb,GAAR,GAGX,EAAO,E,CAAP,E,IAGI,EAAR,E,4CLuIY,EAAyB,EAA0B,EAA7C,C,GAAN,CAAV,EACA,EAAO,EAAM,EAAN,C,EACiB,EAAZ,GAAV,EACA,EAAiB,EAAR,GACT,EAAO,E,CAAP,E,uIRuHQ,E,QAAV,E,EACwB,E,GAAd,E,KAA8B,EAAvB,CAAP,CAAV,EACA,EAAO,EAAM,EAAN,C,EACiB,EAAZ,GAAV,EACA,EAAiB,EAAR,GACT,EAAO,E,CAAP,E,gCsCreI,E,QAAR,E,8DtCwe0B,E,QAA1B,G,mCbrdF,GAAsB,G,GACtB,GAAa,G,GACN,G,EAFP,GAAsB,G,GACtB,GAAa,G,GACN,G,EAFP,GAAsB,G,GACtB,GAAa,G,GACN,G,yKCnBE,E,YAMA,E,YAIA,E,YACA,E,0DAxBG,E,OACV,E,KAAM,E,KACN,E,KAAM,E,KACN,E,KAAM,E,KACN,E,KAAM,E,UACC,E,4COoIA,E,qEA2DyB,E,KAi2CxB,E,KAAA,EAAV,E,EAKmC,EAAoB,EAA7C,E,OACkB,E,GACf,E,KADb,EACA,GACO,EAAwB,EAAK,EAApC,E,EACqC,E,GAAxB,E,KA12C2B,EAk2CxB,EAAR,GAAsB,EAAN,G,SAAJ,EAA0B,EAAO,E,KAAX,EAA1C,EAQqC,CAArC,GACW,EARH,EAAQ,EAAR,GAAsB,EAAN,G,SAAJ,EAA0B,EAAO,E,KAAX,E,EACzB,E,KAAT,CAOkC,EAAN,CAApC,G,OACO,E,4CAl6CkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cAC7C,E,GAAiB,E,KAAjB,CAAT,G,sDPjBI,E,OAAe,EAAqB,EAAM,EAAd,EAAN,IAAtB,E,OACgB,E,OAAA,CAAH,SSohCjB,CTphCG,EAAZ,EACU,EAAV,E,EACyB,EAAJ,G,IACR,E,GAAX,E,EAAgB,EAAT,EAAiB,EAAI,EAAJ,CAAjB,C,CAAP,EAD4B,E,GAAA,E,IAKL,GAAO,EADpB,I,EAAU,K,EAAK,EAAM,EAAN,CAAL,EAAgB,GAAhB,EAAuB,GAC9B,CAAf,E,EACuB,EAAI,EAAJ,C,EACrB,EAAO,EAAW,EAAI,EAAJ,CAAX,C,CAAP,EAD4B,E,GAAA,E,WAGvB,E,4CA9FsB,E,KAAM,EAAG,EAAnB,EAAyB,EAAG,EAAG,EAAzC,E,wGAkEC,E,YACA,E,iBAQV,E,KAHY,EAAO,EAAP,C,KAIZ,E,KAHY,E,IAAQ,EAAR,C,UAIL,E,gEA3FW,E,OAAK,EAAL,EAAR,E,OACqB,E,QAAA,CAAH,SSonCnB,CTpnCK,EAA0B,EAA1B,CAAd,E,EACwB,E,KAAM,EAAG,EAAnB,E,EACW,EAAV,G,EAAgB,EAAO,EAAvB,EACiB,EAAG,EAA5B,E,mDAae,E,KAAM,EAAb,E,qDAOY,E,KAAK,EAAL,EAAR,E,WAAA,G,EAAgC,EAAV,G,EAAgB,EAAG,EAAnB,EAAyB,EAAG,EAA5D,E,sEO6Ia,E,GAAc,M,uEP3CtB,E,KAAK,EAAT,E,EACC,E,KAAK,EAAT,EAAgB,EAAhB,C,GACI,E,KAAK,EAAT,EAAgB,EAAhB,C,GACI,E,KAAK,EAAT,EAAgB,EAAhB,C,uDAjGa,E,KAAK,EAAL,EAAR,E,WAGO,G,EAFG,E,SAAc,EAAd,E,WAAV,E,EACU,E,SAAc,EAAd,E,WAAV,EACgB,EAAnB,E,sDAIW,E,OAAK,EAAL,EAAR,E,OACqB,E,QAAA,CAAH,SSilCrB,CTjlCO,EAA0B,EAA1B,CAAd,E,EACuB,E,KAAM,EAAG,EAAnB,EAAb,E,EACuB,E,KAAM,EAAO,EAAvB,EAAb,E,EACiB,E,KAAA,GAAO,EAAM,EAAM,EAA7B,E,mDAYW,E,OAAK,EAAL,EAAR,E,OACO,E,KAAA,G,EAAO,K,EAAA,GAAO,EAAG,EAA3B,E,qDAIW,E,OAAK,EAAL,EAAR,E,OACO,E,KAAA,G,EAAO,K,EAAA,G,EAAiB,EAAV,G,EAAgB,EAAG,EAAnB,EAAyB,EAAjD,E,6DASW,E,OAAK,EAAL,EAAR,E,SACY,E,SAAc,EAAd,E,WAA4B,EAAM,EAAN,CAAU,EAApB,EAAM,EAAN,EAAzB,I,YACE,G,EAAO,K,EAAA,G,cAAiB,E,QAAlC,E,6DAIW,E,OAAK,EAAL,EAAR,E,OACQ,E,OAAK,EAAL,EAAR,E,cACO,G,EAAO,K,EAAA,G,EAAO,K,EAAA,GAAO,EAA/B,E,sDYhHgB,E,GACrB,E,KADJ,EAC8B,EAAhB,CAAV,CAAJ,EACM,EAAU,MAAkB,EAAlB,CAAV,CAAJ,EAAgE,I,cAChC,E,QAAhC,E,EAGsB,E,KAAJ,CAA0B,EAA1B,CAAlB,EACI,EAAJ,E,MAAmC,EAAe,EAAf,C,WAAJ,C,EAAsC,E,KAA1C,CAAd,G,EACS,Eb4PiB,EAA5B,CAAb,E,GAE6B,EAAhB,CAAsB,EAAvB,C,EAAR,CAAJ,EACE,EAAgB,E,GACT,E,EAAP,GAIiB,EAAM,E,GAAZ,EAAb,EACoB,EAAY,EAAM,E,UAAV,CAA5B,KarQE,EAMe,EAAX,CAAJ,EACe,EAAO,EAApB,GACa,EAAO,EAApB,GACO,EAAO,EAA4B,EAA1C,GAES,EAAO,EAAlB,I,sDA6FuB,E,GAAnB,E,KAAA,CAAJ,EACM,EAAQ,EAAR,CAAJ,EAAoC,G,aACrB,EAAyB,EAAQ,EAAR,GAAW,EApH6B,EAoHhF,E,EACA,E,KAAe,E,MAER,E,QAAkB,EAAgB,EAAhB,CAAlB,CAAiD,EAA1D,G,gvIGtHiB,E,YACC,E,YACP,E,oKCCP,EAAc,MAAd,CAAJ,EAAyE,I,cACrB,EAAqB,EAA5D,E,OAIb,E,KAAc,E,oBACd,E,KAAiB,E,KACjB,E,KAAkB,E,+TIoDK,E,GAAnB,E,EAjBgD,EAA7C,C,GAAwE,EAAxE,CAiBH,CAAJ,EAAyD,G,aACrC,EAA2B,EAAgB,EAAhB,CAA3B,CAAR,G,mDAcW,E,GAAnB,E,EAhCgD,EAA7C,C,GAAwE,EAAxE,CAgCH,CAAJ,EAAyD,G,eACzD,E,KAAY,EAIwC,EAAhB,CAA3B,CAJU,EAInB,G,6FH3EiB,E,YACD,E,YACL,E,YACI,E,YACD,E,kECrBhB,E,KAAS,E,KAAA,G,IAAuB,E,KAAS,E,KC6EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7EM,G,EC6EgB,CAAlD,EAAK,EAAL,ED7EyB,EAAZ,CAApB,ED8CO,E,6DCxCP,E,KAAS,E,KAAA,G,IAA2B,E,KAAS,E,KCuEV,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvEU,G,ECuEY,CAAlD,EAAK,EAAL,E,EDvEyB,CAAZ,CAAY,CAAhC,EDwCO,E,6DClCP,E,KAAS,E,KAAA,G,IAAoB,E,KAAS,E,KCiEH,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDjEG,G,ECiEmB,CAAlD,EAAK,EAAL,EDjEsB,EAAT,CAApB,EDkCO,E,6DC5BP,E,KAAS,E,KAAA,G,IAAwB,E,KAAS,E,KC2DP,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED3DO,G,EC2De,CAAlD,EAAK,EAAL,E,ED3DsB,CAAT,CAAS,CAA7B,ED4BO,E,6DCtBP,E,KAAS,E,KAAA,G,IAAoB,E,KAAS,E,KCqDH,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDrDG,G,ECqDmB,CAAlD,EAAK,EAAL,EDrDsB,EAAT,CAApB,EDsBO,E,6DChBP,E,KAAS,E,KAAA,G,IAAwB,E,KAAS,E,KC+CP,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED/CO,G,EC+Ce,CAAlD,EAAK,EAAL,E,ED/CsB,CAAT,CAAS,CAA7B,EDgBO,E,6DCVP,E,KAAS,E,KAAA,G,IAA2B,E,KAAS,E,KCyCV,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDzCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAGA,EAAO,E,EACY,E,GAAjB,EACmB,EAAb,CAAF,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D,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTwHO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDShIM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/EgB,CAAlD,EAAK,EAAL,EU+EoB,EAAzB,G,EAE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CAAlD,EAAK,EAAL,EUkJ0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZjLO,E,6Da9CP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KX6EJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EW7EI,G,EX6EkB,CAAlD,EAAK,EAAL,EW7EkB,EAAzB,Eb8CO,E,sDaxCH,E,KAAc,E,KXuEiB,E,EWvEjB,G,EXuEuC,CAAlD,EAAK,EAAL,EWvEH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EXiE1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GWjEb,GbuCK,E,sDahCH,E,KAAc,E,KX+DiB,E,EW/DjB,G,EX+DuC,CAAlD,EAAK,EAAL,EW/DH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EXyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GWzDb,Gb+BK,E,6DaxBH,E,KAAc,E,KXuDiB,E,EWvDjB,G,EXuDuC,CAAlD,EAAK,EAAL,EWvDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KXsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EWtDM,G,EXsDgB,CAAlD,EAAK,EAAL,EWtDoB,EAAzB,GbuBK,E,6DahBH,E,KAAc,E,KX+CiB,E,EW/CjB,G,EX+CuC,CAAlD,EAAK,EAAL,EW/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KX8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EW9CM,G,EX8CgB,CAAlD,EAAK,EAAL,EW9CoB,EAAzB,GbeK,E,6Dc9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZ6EL,E,EY7EK,G,EZ6EiB,CAAlD,EAAK,EAAL,EY7EwB,E,IAAiC,EZwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EY7EwB,E,EZwEhB,GYvBN,CAjDT,Ed8CO,E,6DcxCP,E,YAAS,G,IAAoC,E,KZkE9B,G,IYlEuC,E,KAAS,E,KZuE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EYvE4B,G,EZuEN,CAAlD,EAAK,EAAL,EYvE+C,EA2C7C,CA3CT,EdwCO,E,6DclCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZiE1B,E,EYjE0B,G,EZiEJ,CAAlD,EAAK,EAAL,E,EYjEyC,C,IAA4B,EAyCtD,G,EZwBa,E,EAAsB,CAAlD,EAAK,EAAL,EYjEyC,E,EAyC1B,GAAb,CZmBF,CY5DP,EdkCO,E,6Dc5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,KZ2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EYxBY,E,EZwBgB,E,EY3DuC,G,EZ2DjB,CAAlD,EAAK,EAAL,E,EY3DsD,CAmCpD,CZmBF,CYtDP,Ed4BO,E,6DctBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZqDL,E,EYrDK,G,EZqDiB,CAAlD,EAAK,EAAL,EYrDwB,E,IAAmB,E,KAAS,E,KZqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EYrDwB,E,EZqDI,E,EYrDwB,G,EZqDF,CAAlD,EAAK,EAAL,EYrD2C,EAiCzC,CAjCT,EdsBO,E,6DchBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZ+C1B,E,EY/C0B,G,EZ+CJ,CAAlD,EAAK,EAAL,E,EY/CyC,C,IAA4B,E,KAAS,E,KZ+ClD,E,EAAsB,CAAlD,EAAK,EAAL,EY/CyC,E,EZ+Cb,E,EY/CkD,G,EZ+C5B,CAAlD,EAAK,EAAL,E,EY/CiE,CA+B/D,CZWF,CY1CP,EdgBO,E,6DcVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KZyCL,E,EYzCK,G,EZyCiB,CAAlD,EAAK,EAAL,EYzCwB,E,IAAmB,E,KAAS,E,KZyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EYzCwB,E,EZyCI,E,EYzCwB,G,EZyCF,CAAlD,EAAK,EAAL,EYzC2C,EAazC,CAbT,EdUO,E,6DcJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KZmC1B,E,EYnC0B,G,EZmCJ,CAAlD,EAAK,EAAL,E,EYnCyC,C,IAA4B,E,KAAS,E,KZmClD,E,EAAsB,CAAlD,EAAK,EAAL,EYnCyC,E,EZmCb,E,EYnCkD,G,EZmC5B,CAAlD,EAAK,EAAL,E,EYnCiE,CAW/D,CZmBF,CY9BP,EdIO,E,sDe9CM,E,Yb6EsB,E,Ea7ER,G,Eb6E8B,CAAlD,EAAK,EAAL,Ea7EM,E,EAA2C,EbwEzC,G,EAAA,GaxEF,CAAb,E,EACA,E,KAAc,E,Kb4EqB,E,Ea5ErB,G,Eb4E2C,CAAlD,EAAK,EAAL,Ea5EkB,GAAzB,Ef6CO,E,sDevCU,E,YbsEkB,E,EatEJ,G,EbsE0B,CAAlD,EAAK,EAAL,EatEM,E,EAA4C,EbiE1C,G,EAAA,GajEF,CAAb,E,EACA,E,KAAc,E,KbqEqB,E,EarErB,G,EbqE2C,CAAlD,EAAK,EAAL,EarEkB,GAAzB,EfsCO,E,sDehCM,E,Yb+DsB,E,Ea/DR,G,Eb+D8B,CAAlD,EAAK,EAAL,Ea/DM,E,EAA2C,Eb0DzC,G,EAAA,Ga1DF,CAAb,E,EACA,E,KAAc,E,Kb8DqB,E,Ea9DrB,G,Eb8D2C,CAAlD,EAAK,EAAL,Ea9DkB,GAAzB,Ef+BO,E,sDezBU,E,YbwDkB,E,EaxDJ,G,EbwD0B,CAAlD,EAAK,EAAL,EaxDM,E,EAA4C,EbmD1C,G,EAAA,GanDF,CAAb,E,EACA,E,KAAc,E,KbuDqB,E,EavDrB,G,EbuD2C,CAAlD,EAAK,EAAL,EavDkB,GAAzB,EfwBO,E,6DelBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbiDJ,E,EajDI,G,EbiDkB,CAAlD,EAAK,EAAL,EajDkB,E,IAAyB,E,KAAc,E,KbiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EajD6B,G,EbiDP,CAAlD,EAAK,EAAL,EajD2C,EAAzB,IAAzB,EfkBO,E,6DeZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kb2CR,E,Ea3CQ,G,Eb2Cc,CAAlD,EAAK,EAAL,Ea3CkB,E,IAAkC,E,KAAc,E,Kb2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea3CsC,G,Eb2ChB,CAAlD,EAAK,EAAL,Ea3CgD,EAA9B,IAAzB,EfYO,E,wDgB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdyEG,E,EczEH,G,EdyEyB,CAAlD,EAAK,EAAL,E,EczEO,CAAd,E,EACA,E,KAAc,E,KdwEqB,E,EcxErB,G,EdwE2C,CAAlD,EAAK,EAAL,EcxEgC,EAAS,EAAT,CdmEhC,CcnEP,EhByCO,E,wDgBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdiEG,E,EcjEH,G,EdiEyB,CAAlD,EAAK,EAAL,E,EcjEO,CAAd,E,EACA,E,KAAc,E,KdgEqB,E,EchErB,G,EdgE2C,CAAlD,EAAK,EAAL,EchEgC,EAAU,EAAV,Cd2DhC,Cc3DP,EhBiCO,E,sDgB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KdyDX,E,EczDW,G,EdyDW,CAAlD,EAAK,EAAL,E,EczDqB,CAA5B,E,EACA,E,KAAc,E,KdwDqB,E,EcxDrB,G,EdwD2C,CAAlD,EAAK,EAAL,EcxDkB,E,EAAS,CAAT,CAAzB,EhByBO,E,sDgBnBW,E,KAAc,E,KdkDG,E,EclDH,G,EdkDyB,CAAlD,EAAK,EAAL,EclDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EdiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KcjD0C,EAAV,Cd4ChC,Cc5CP,EhBkBO,E,sDgBZW,E,KAAc,E,Kd2CG,E,Ec3CH,G,Ed2CyB,CAAlD,EAAK,EAAL,Ec3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,Ed0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,Kc1C2C,EAAX,CdqChC,CcrCP,EhBWO,E,sDgBLW,E,YdoCiB,E,EcpCH,G,EdoCyB,CAAlD,EAAK,EAAL,EcpCW,E,GAAJ,CAAd,E,EAC0B,E,Kd8BX,Gc9Bf,E,EACA,E,KAAc,E,KdkCqB,E,EclCrB,G,EdkC2C,CAAlD,EAAK,EAAL,EclCoC,E,EAAO,C,CAAX,CAAvC,EhBGO,E,6DgBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kd2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ec3BI,G,Ed2BkB,CAAlD,EAAK,EAAL,Ec3BkB,E,EAA0B,CAA1B,CAAzB,EhBJO,E,6DgBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcpBI,G,EdoBkB,CAAlD,EAAK,EAAL,EcpBkB,E,EAA2B,CAA3B,CAAzB,EhBXO,E,sDgBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KdaG,E,EcbH,G,EdayB,CAAlD,EAAK,EAAL,EcbO,EAAd,E,EACA,E,KAAc,E,KdYqB,E,EcZrB,G,EdY2C,CAAlD,EAAK,EAAL,EcZkB,E,EAAS,CAAT,CAAzB,EhBnBO,E,sDgByBW,E,KAAc,E,KdMG,E,EcNH,G,EdMyB,CAAlD,EAAK,EAAL,EcNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EdAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EcAmC,CAAzB,CAAzB,EhB1BO,E,sDgBgCW,E,KAAc,E,KdDG,E,EcCH,G,EdDyB,CAAlD,EAAK,EAAL,EcCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EdPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EcOoC,CAA1B,CAAzB,EhBjCO,E,sDgBuCW,E,YdRiB,E,EcQH,G,EdRyB,CAAlD,EAAK,EAAL,EcQW,E,GAAJ,CAAd,E,EAC4B,E,Kddb,Gccf,E,EACA,E,KAAc,E,KdVqB,E,EcUrB,G,EdV2C,CAAlD,EAAK,EAAL,EcUoC,E,EAAS,C,CAAb,CAAvC,EhBzCO,E,wDgB+CW,E,KAAc,E,KdhBG,E,EcgBH,G,EdhByB,CAAlD,EAAK,EAAL,EcgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KdjBG,E,EciBH,G,EdjByB,CAAlD,EAAK,EAAL,E,EciBO,CAAd,E,EACA,E,KAAc,E,KdlBqB,E,EckBrB,G,EdlB2C,CAAlD,EAAK,EAAL,EckBgC,EAAS,EAAT,CdvBhC,CcuBP,EhBjDO,E,wDgBuDW,E,KAAc,E,KdxBG,E,EcwBH,G,EdxByB,CAAlD,EAAK,EAAL,EcwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KdzBG,E,EcyBH,G,EdzByB,CAAlD,EAAK,EAAL,E,EcyBO,CAAd,E,EACA,E,KAAc,E,Kd1BqB,E,Ec0BrB,G,Ed1B2C,CAAlD,EAAK,EAAL,Ec0BgC,EAAU,EAAV,Cd/BhC,Cc+BP,EhBzDO,E,sDgB+DW,E,KAAc,E,KdhCG,E,EcgCH,G,EdhCyB,CAAlD,EAAK,EAAL,EcgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KdjCd,E,EciCc,G,EdjCQ,CAAlD,EAAK,EAAL,E,EciCwB,CAA/B,E,EACA,E,KAAc,E,KdlCqB,E,EckCrB,G,EdlC2C,CAAlD,EAAK,EAAL,EckCoC,E,EAAY,C,CAAhB,CAAvC,EhBjEO,E,6DgBuEW,E,KAAc,E,KdxCG,E,EcwCH,G,EdxCyB,CAAlD,EAAK,EAAL,EcwCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdzCJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcyCI,G,EdzCkB,CAAlD,EAAK,EAAL,EcyCkB,E,EAA0B,CAA1B,CAAzB,EhBxEO,E,6DgB8EW,E,KAAc,E,Kd/CG,E,Ec+CH,G,Ed/CyB,CAAlD,EAAK,EAAL,Ec+CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KdhDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcgDI,G,EdhDkB,CAAlD,EAAK,EAAL,EcgDkB,E,EAA2B,CAA3B,CAAzB,EhB/EO,E,6DgBqFW,E,KAAc,E,KdtDG,E,EcsDH,G,EdtDyB,CAAlD,EAAK,EAAL,EcsDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,KdvDR,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EcuDQ,G,EdvDc,CAAlD,EAAK,EAAL,EcuDkB,E,EAA+B,CAA/B,CAAzB,EhBtFO,E,mDV8HkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cACnD,E,GAAiB,E,KAAjB,CAA+B,EAAzC,G,2DQ6DY,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,E,IAAf,G,EACO,E,kEmB/OO,E,QAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,2DnBiPO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,EAAQ,GAAR,CAAf,G,EACI,E,iBAAA,EAAmB,EAAnB,CAAJ,E,EACE,E,iBAAU,EAAK,E,KAAS,EAAT,CAAf,I,EAEA,E,iBAAW,EAAK,E,KAAS,EAAT,CAAhB,I,EAEK,E,kEmBtPO,E,QAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DnBwPO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,EAAK,EAAI,GAAJ,CAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,EAAK,EAAI,GAAJ,CAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEmBrQO,E,QAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DnBuQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,E,EAAK,C,IAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,E,EAAK,C,IAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEmBpRO,E,QAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EfkDjB,GelDG,G,OACD,E,KAAV,E,+DAKO,E,KAAa,E,YAAa,E,KAAc,E,WfiDnB,E,EejDmB,G,EfiDG,CAAlD,EAAK,EAAL,EejDiC,EAAyB,G,CAA9B,CAArB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAc,E,KAAc,E,Wf2CrB,E,Ee3CqB,G,Ef2CC,CAAlD,EAAK,EAAL,Ee3CmC,EAAyB,I,CAA/B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAY,E,KAAc,E,WfqCnB,E,EerCmB,G,EfqCG,CAAlD,EAAK,EAAL,E,EerC6B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAQ,E,KAAc,E,Wf+Bf,E,Ee/Be,G,Ef+BO,CAAlD,EAAK,EAAL,Ee/B6B,EAAtB,G,OACG,E,KAAV,E,6DAKa,E,YfyBe,E,EezBD,G,EfyBuB,CAAlD,EAAK,EAAL,EezBa,E,EAAuC,EfoB5C,G,EAAA,G,CepBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YfkBe,E,EelBD,G,EfkBuB,CAAlD,EAAK,EAAL,EelBa,E,EAAuC,Efa5C,G,EAAA,G,CebC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YfWe,E,EeXD,G,EfWuB,CAAlD,EAAK,EAAL,EeXa,E,EAAuC,EfM5C,G,EAAA,G,CeNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YfIe,E,EeJD,G,EfIuB,CAAlD,EAAK,EAAL,EeJa,E,EAAuC,EfD5C,G,EAAA,G,CeCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EfFjB,GeEG,G,OACD,E,KAAV,E,+DAKa,E,YfHe,E,EeGD,G,EfHuB,CAAlD,EAAK,EAAL,EeGa,E,EAAuC,EfR5C,G,EAAA,G,CeQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EfJQ,E,EeIoB,G,EfJE,CAAlD,EAAK,EAAL,EeIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YfVe,E,EeUD,G,EfVuB,CAAlD,EAAK,EAAL,EeUa,E,EAAuC,Eff5C,G,EAAA,G,CeeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EfXO,E,EeWsB,G,EfXA,CAAlD,EAAK,EAAL,EeWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YfjBe,E,EeiBD,G,EfjBuB,CAAlD,EAAK,EAAL,EeiBa,E,EAAuC,EftB5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OACK,E,QAAf,E,EACgB,EAAI,EAAJ,C,EACU,EAA2B,EAAY,EAAZ,CAA3B,CAAR,G,IAAkE,E,SAAlE,EAA+D,E,EAAlE,E,GAAA,G,KACJ,EAAY,EAAY,EAAZ,CAAZ,CAAuC,EAAhD,GAES,EAAwB,EAA2B,EADxC,EAHK,E,GAAF,E,WAOlB,E,8CRsHG,E,KAOmC,G,EANnC,EAMwC,G,EAAA,G,aAArB,G,wD2B7JI,E,KAAN,E,EAAY,EAA5B,G,KACT,GAAJ,E,OACS,EAAP,E,yEAfO,E,YACA,E,YACA,E,YACA,E,UACO,E,sCAehB,E,KAAmB,E,gCAEX,E,mBAOJ,E,KAA2B,E,OpB3NhB,G,QoBkOX,E,KAAa,E,KAAc,E,OpB7NI,E,EoB6NJ,G,EpB7N0B,CAAlD,EAAK,EAAL,EoB6NU,E,QAIb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,KACb,E,KAAkB,E,KAAJ,GAAe,EAAf,C,IAAyB,EAAJ,G,EAArB,E,EAAqB,GAAtB,C,QAab,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAAa,E,KAAc,E,OpBhPI,E,EoBgPJ,G,EpBhP0B,CAAlD,EAAK,EAAL,EoBgPU,E,QAab,E,KAAa,E,KAAc,E,OpB7PI,E,EoB6PJ,G,EpB7P0B,CAAlD,EAAK,EAAL,EoB6PU,E,KACb,E,KAAa,E,KAAc,E,OpB9PI,E,EoB8PJ,G,EpB9P0B,CAAlD,EAAK,EAAL,EoB8PU,E,KACb,E,KAA2B,E,OpBpQhB,G,KoBqQX,E,KAA2B,E,OpBrQhB,G,QoBwQX,E,KAAa,E,KAAc,E,OpBnQI,E,EoBmQJ,G,EpBnQ0B,CAAlD,EAAK,EAAL,EoBmQU,E,KACb,E,KAAa,E,KAAc,E,OpBpQI,E,EoBoQJ,G,EpBpQ0B,CAAlD,EAAK,EAAL,EoBoQU,E,KACb,E,KAAa,E,KAAc,E,OpBrQI,E,EoBqQJ,G,EpBrQ0B,CAAlD,EAAK,EAAL,EoBqQU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBxNhB,G,QoB4NX,E,KAA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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/0a78010a7801?v=0.6.4 **/\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT = 12;\n\n/** https://graypaper.fluffylabs.dev/#/68eaa1f/24ee0024ee00?v=0.6.4 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const pageIdx = u32(currentAddress >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n const relAddress = currentAddress % PAGE_SIZE;\n const page = this.pages.get(pageIdx);\n const spaceInPage = PAGE_SIZE - relAddress;\n\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** https://graypaper.fluffylabs.dev/#/9a08063/2cc5022cc502?v=0.6.6 */\nexport function decodeSpi(data: Uint8Array): Program {\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const _heapPages = decoder.u16();\n const _stackSize = decoder.u24();\n\n const _roMem = decoder.bytes(roLength);\n const _rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n return deblob(code);\n}\n\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { RUN } from \"./instructions-exe\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, JumpTable, Program, ProgramCounter, decodeArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { InitialChunk, InitialPage, buildMemory } from \"./api-generic\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n): void {\n const p = deblob(liftBytes(program));\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { VmInput, VmOutput, getAssembly, runVm } from \"./api-generic\";\nimport { deblob, decodeSpi, extractCodeAndMetadata, liftBytes } from \"./program\";\n\nexport * from \"./api\";\nexport { runVm, getAssembly } from \"./api-generic\";\nexport { wrapAsProgram } from \"./program-build\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n let program = liftBytes(input);\n let output = \"\";\n\n if (withMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(program);\n program = data.code;\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += data.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n if (kind === InputKind.Generic) {\n const p = deblob(program);\n return output + getAssembly(p);\n }\n\n if (kind === InputKind.SPI) {\n const p = decodeSpi(program);\n return output + getAssembly(p);\n }\n\n return `Unknown kind: ${kind}`;\n}\n\nexport function runProgram(input: u8[], registers: u64[], kind: InputKind): VmOutput {\n if (kind === InputKind.Generic) {\n const vmInput = new VmInput();\n vmInput.registers = registers;\n vmInput.gas = 10_000;\n vmInput.program = input;\n\n const output = runVm(vmInput, true);\n console.log(`Finished with status: ${output.status}`);\n return output;\n }\n\n if (kind === InputKind.SPI) {\n throw new Error(\"SPI running not supported yet\");\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { Program, deblob, decodeArguments, liftBytes, resolveArguments } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n registers: u64[] = new Array(NO_OF_REGISTERS).fill(0);\n pc: u32 = 0;\n gas: i64 = 0;\n program: u8[] = [];\n pageMap: InitialPage[] = [];\n memory: InitialChunk[] = [];\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const p = deblob(liftBytes(input.program));\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < registers.length; r++) {\n registers[r] = input.registers[r];\n }\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, input.pageMap, input.memory);\n\n const int = new Interpreter(p, registers, memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = p.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n return this.gas < 0;\n }\n}\n","import { Arguments, REQUIRED_BYTES, nibbles } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"6kDG4JW,EAAT,E,GA/DiD,EAAxC,CAgET,EACA,EAAO,EAAQ,EAAR,C,EACa,E,GAxDc,EAAzB,CAwDyB,EAAd,CAAP,E,cACK,EAA0B,EAA1B,CAAhB,EACO,E,GApEwC,EAAxC,CAoEP,E,SApCW,E,GAhCoC,EAAxC,CAgCP,EACI,CAAJ,EACoB,E,GAAA,CAAqB,EAA0B,IAA1B,CAArB,C,CAAP,E,cACX,EAES,E,GAAX,E,CACW,E,cACX,EAAY,E,GACZ,EAAY,EAnCmC,E,GAAqB,EAArB,CAA1B,C,SAiDjB,EAAQ,EAAR,CAAJ,EAAgC,E,MAAP,E,cAAA,EAAP,GAClB,IACY,E,EAAS,E,GA/BrB,EAEe,EAAR,G,GAAsC,EOrG/C,IACS,GAAL,CAAJ,EAAyC,G,WACS,EAAK,EAAL,CAAtB,IAArB,C,GPmGgD,EAAnB,E,EAkBvB,E,GAAX,EACA,EAU+C,EAAL,CAAc,EA7BjD,EA6Bc,CAVA,G,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,MAoLT,EAAD,CAAJ,E,EAGiB,EAFY,EAAM,EAAzB,CAAV,E,GA5NkC,EAAzB,CA8NL,CAAJ,EACE,IACE,E,GAAF,G,MF7Dc,E,GAAhB,EAC8B,EAAZ,C,CAAP,E,cACA,EAAY,EAAZ,CAAX,EAC0B,EAAR,CAAP,E,cAIP,EAAO,GAAP,CAAJ,EAEa,EAAQ,EAAd,EAIA,E,MADiB,E,SAAJ,CAAlB,EACW,CAAN,CAAL,EAEM,E,CAAN,EADY,EAAgB,EAAK,EAAL,CAAhB,CAAkC,EAAzC,EAG2B,EAAK,EAAL,CAAhB,EAAK,EAAL,E,CAAP,E,cAIA,E,GAAX,EADW,E,GAAX,EAEA,EAAU,EAAY,E,IAClB,EAAJ,EAAU,EAAY,E,IAGlB,EAAiB,EAAM,EAhIU,EAAN,CAgIA,EAhID,CAAgC,EAAjC,CAA3B,GADK,GAiIH,CAAJ,EAvHE,EAwHsB,EAzHxB,GA4HO,EAAD,CAAJ,EACoB,EAAM,EAxJO,EAAN,CAA3B,GADK,G,EA0J6B,EAAP,C,CAAT,EAhJlB,EAgJkB,EAjJpB,GAoJS,EAAD,CAAJ,EAAY,I,KAAqB,EAAP,C,aArGZ,E,CAAP,E,cACK,E,GAAhB,EAC8B,EAAZ,C,CAAP,E,cAEU,EA5G+B,EAA3B,CAA6C,E,GAAe,EAAf,CAA/D,CA4GP,E,GACA,EAGgB,EAAZ,CAAJ,EACc,EAAM,EAAlB,EACA,EAA2B,EAAY,EAAZ,CAA8B,EAAY,EAAZ,CAA9B,CAAZ,E,GACE,EAnHiC,EAA3B,CAA6C,E,GAAe,EAAf,CAA/D,CAmHL,E,GACA,GAKE,EAAY,EAAZ,CAAJ,EACyB,EAhIqB,EAA3B,CAAZ,GAgIL,E,GACA,EAC6B,EAAX,C,CAAP,E,cACC,EAAM,EAAlB,EACA,EAC2B,EAAW,EAAX,CAA6B,EAAY,EAAZ,CAA7B,CAAZ,E,IAIjB,EAAe,EAAY,EAAZ,C,GAIJ,EAAY,EAAZ,CAAX,EAC0B,EAAR,CAAP,E,cAC2D,EAApD,EAA2B,EAA3B,CAA4C,EAA5C,EAAP,E,cAGE,EAA2B,EAA3B,CAA4C,EAAzD,GAII,EAAO,GAAP,CAAJ,EAEa,EAAQ,EAAd,EAIA,E,MADiB,E,SAAJ,CAAlB,EACW,CAAN,CAAL,EAEM,E,CAAN,EADY,EAAgB,EAAK,EAAL,CAAhB,CAAkC,EAAzC,EAG2B,EAAK,EAAL,CAAhB,EAAK,EAAL,E,CAAP,E,cAGQ,EAAM,EAzFY,EAAN,CAyFF,EAzFC,CAAgC,EAAjC,CAA3B,CADK,GA0FP,EACA,E,KACA,EAAa,E,GACT,EAAJ,EAAU,EAAY,E,IACd,EAAM,EApFuB,EAAN,CAoFb,EApFY,CAAgC,EAAjC,CAA3B,CAoFoB,EArFtB,GAwFA,I,GAAe,EAAK,EAAL,C,IACT,EAAM,EA3GuB,EAAN,CAA3B,GATA,EADK,GAqH4B,EAAK,EAAL,CAAnB,CA5GhB,G,MAoOgC,E,EAAd,EAAP,E,cACD,E,EAAA,CAAoC,EAArC,CAAiD,EAAlD,CAAR,EAGmB,EA3MZ,IA2MP,EAEA,EAC6B,EAA0B,EAA1B,CAAT,GAAP,E,cAIiB,EAAxB,EAAQ,EAAR,IAAJ,EAEa,E,GAAX,E,EADA,IAQc,EAA0B,GAA1B,CAAT,GADS,E,iBApBR,CAGH,E,CAsBU,EAAN,CAAX,EACW,EAAP,CAAJ,E,EAOA,EAAiC,EAAW,EAAX,CAFlB,EAAO,EAAP,CAAf,EAEyB,EAAX,E,GACd,E,KACA,E,KAGyB,EAAQ,EAAR,CAAyB,EAA3C,CAAP,E,KAEQ,EAAM,EArOd,IAuOY,EAAM,EAAlB,E,MA8CkB,EAAlB,EACkB,EACd,GAAyC,EAAc,EAAd,CAAZ,EAAyC,EAAzC,E,GAAjC,EAA6E,EAClE,IACE,E,GACL,IAAM,EA1Rd,G,EA2RwB,EAAK,EAAL,C,EACV,EAjUqB,EAAN,CAiUrB,IAjUN,CAiUgB,EAlUlB,GAmUqB,EAAd,E,EAAiB,EAAK,EAAL,C,EACN,EAhTmB,EAAN,CAgTT,EAhTQ,CAAgC,EAAjC,CAgTjB,IAhTV,CAgTwB,EAjT1B,GAgTwC,E,GAAF,E,IAFE,E,GAAF,E,IAY1B,IANG,I,EAMa,CAAsB,EAAtB,C,EAErB,IAAP,E,MEnTA,E,MAAQ,E,OAEI,EAAR,EACa,EAAb,EACA,EACO,EAAP,EACO,EAAP,EAGiB,EAAL,CAAZ,EACM,E,GAlGuC,EAAxC,CAkGL,EACA,EAAO,EAAO,EAAP,C,EACE,EAAP,EACiB,EAAb,E,KA3FwB,EAAzB,CA2FC,CAAJ,EACE,E,EAvFqC,EAArB,CAuFJ,EAvFG,C,GAwFF,EAAb,EACgB,EAAyB,EAAzB,CAAhB,EACO,EAAP,EAEI,E,GA3GqC,EAAxC,CA2GH,E,IAEW,EAAb,EACA,EAEW,EADL,E,GA/GuC,EAAxC,CAgHD,CAAJ,EAtCM,EAAV,EACA,EAAO,EAAM,IAAN,C,EACe,EAAZ,GAAR,EACA,EAAO,E,CAAP,E,IAqCU,E,GAlHqC,EAAxC,CAkHH,EACA,EAAO,EAAO,EAAP,C,EACY,EAAb,E,KA1GsB,EAAzB,CA0GG,CAAJ,EACE,E,EAtGmC,EAArB,CAsGF,EAtGC,C,GAuGG,EAAyB,EAAzB,CAAhB,GAEI,E,GAxHmC,EAAxC,CAwHD,E,IAES,EAAX,EACY,EAAZ,EACU,EAAV,EACQ,EAAR,EACO,E,GA9HoC,EAAxC,CA8HH,EACQ,EAAR,GAEK,EAAP,EAGM,EAAN,EACW,EAAP,CAAJ,EACS,E,KAtIoC,EAAxC,CAsIH,EACoC,EAAL,C,EA7HH,EAAzB,CA6He,CAAP,E,cACN,EAckB,IAAzB,CAAJ,EACE,EAAoB,E,GACpB,EAAW,E,IAEX,EAAS,E,GAtI8B,EAAd,CAAlB,G,CAsIP,EAIO,EAAyB,EAAzB,CFiVL,EAAM,IAAN,C,EACC,EAAD,CAAJ,EAAW,GACD,EAAqB,EA9BK,EAAxB,CAAZ,EAEgB,EAAM,EAAN,C,EAAd,K,GACE,E,GAAe,EAAf,EAFJ,E,cAIO,EAXQ,E,GAAe,EAAf,C,GACG,EAAlB,IErUa,EAAP,EAEF,EAAwB,E,GACxB,EAAe,E,GACP,EAAR,G,QF0FA,EAAO,GAAP,CAAJ,EAEa,EAAQ,EAAd,CAAL,GAbK,EAAO,MAAP,GACH,EAAQ,EAAM,EAAsB,EAAX,CAAX,CAAN,CAAR,CAA8C,EAA9C,CAcF,G,EACK,EAdH,EAc6B,CAA1B,CAAL,EACiC,EAAL,CAAhB,CAAkC,EAAzC,CAAL,EACA,EAAM,E,CAAN,GAEgC,EAAK,EAAL,CAAhB,EAAK,EAAL,E,CAAP,E,cAGO,EAAM,EA/LW,EAAN,CAA3B,CADK,GAgMwB,EAAM,EAAN,CAAnB,CAAZ,EAEA,EAYiB,EAAmB,EAAT,CAAJ,EA1Lc,EAAN,CAAD,CAAgC,EAAjC,CAA3B,CADK,IAiLO,E,GAAc,EAAO,EAAK,EAAL,CAAP,CAAd,CAAZ,EACA,EAIgB,EADE,EAAX,CAAL,EAvM+B,EAAN,CAA3B,CADK,GAyMH,E,CACW,E,cACI,EAAmB,EAAT,CAAJ,EAvLY,EAAN,CAAD,CAAgC,EAAjC,CAA3B,CADK,I,UAySH,EAAO,MAAP,CAAJ,EAA0C,G,YAkClB,EAzCjB,EAAQ,EAAR,GACH,GACE,E,EAAA,CAAmC,EAApC,CAAgD,EAAjD,EAsCJ,EACY,EAAZ,EACI,CAAJ,EAxDkB,EAAlB,EALI,EAAQ,GAAR,CAAJ,EAzHO,EAAO,MAAP,GACH,EAAQ,EAAM,EAAsB,EAAX,CAAX,CAAN,CAAR,CAA8C,EAA9C,EACA,I,GA6HI,EAAiG,EAlQlG,IAiQP,EACuD,EAAtB,CAA4B,EAA7B,CAAN,CAAlB,CACkB,CAAO,IAAP,CAAiB,IAAlB,CAA+B,EAAtC,CAAlB,E,KACkB,CACd,EAA2B,EAA3B,CAAJ,EACkB,EAAZ,EAA2B,EAA3B,CAAJ,EAAkC,GAG1B,EAAM,EAAsB,EAAtB,CADC,EACyB,CAAmB,EAAnB,C,EAkDF,EAAM,EAApC,EAAR,E,CACW,E,eAEoC,EAA9B,E,GAAe,EAAf,CAAD,CAAP,E,cACC,EAAM,EAAlB,EA9IgB,E,GAAhB,EACqB,EAAO,EAAP,CAAyB,EAA1B,CAAT,E,cAGM,EAAY,EAAZ,CAA0B,EAA3B,CAAhB,EACiB,EAAb,CAAJ,EACE,EAAe,EAAQ,EAAY,EAAZ,CAAR,C,GAEe,EAA2B,EAA3B,CAA4C,EAA9D,CAAZ,EACgB,EAAY,EAAZ,CAA8B,EAA/B,C,GACH,EAAM,EAAlB,GAIA,EAAe,EAAY,EAAZ,C,GACN,EAtRyC,EAA3B,CAA6C,E,GAAe,EAAf,CAA/D,K,GAsRqB,E,KAkIrB,E,MEpPH,EAAQ,MAAR,CAAJ,EAA4C,G,YACxC,EAAS,EAAT,CAAJ,E,EA2IoB,GAApB,EACA,EACE,EAAU,E,CAAV,EACI,GAAJ,E,EAEsB,C,GAAA,CAA0B,G,CAAlC,CAAyC,GAAzC,CAAZ,EAEA,GAEK,EAAS,EAAT,C,GAEG,EAA4B,EAAQ,EAAR,CAAoB,GAA1B,CAAd,GAAR,CAAZ,IFgKK,EAAD,CAAJ,EAAW,GAC4B,EEtTgB,EAAlB,GFsT9B,EEtTP,EACW,E,GACX,EAAa,E,GACF,EA/HE,E,GAAX,EA+HF,EA9HuB,EA8HD,EA9HC,C,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,GA4Hd,EAAS,E,GAzJgC,EAAd,CAAlB,G,CAyJT,EACU,EAAyB,EAAzB,CAAV,EAEiB,EAAG,EAApB,GACO,E,GC9MY,EAAG,EAAG,EAAG,EAAnB,E,KDqOJ,EAAD,CAAJ,EAAe,EACG,E,CAAP,E,cAEQ,EADY,EAAW,EAA9B,CAAZ,E,GAhMkC,EAAzB,CAiML,CAAJ,EACkC,EAAY,EAA/B,CAAb,E,GAlMgC,EAAzB,CAmMP,EACwB,EAAL,CAAf,CAAJ,EAKI,EAGA,EANE,EAAJ,CAME,GAEqC,EAAS,EAAT,CAA9B,EAAe,EAAf,EAAJ,EAEL,O,KFoQC,EAAD,CAAJ,EAAW,GAC4B,EAAM,EAAtC,EAA+C,EAA/C,C,EcvjBU,E,KACC,E,KACP,E,KACc,E,KAKb,E,GACZ,EAAS,E,GACT,EAAQ,E,GACR,EAAkB,E,GACX,E,4CMaG,E,OACV,E,KAAY,E,KACZ,E,KAAW,E,UACJ,E,GAkBA,E,MdqIP,EAAO,EAAO,IAAP,C,EAGG,EAAM,IAAN,CAAR,EADQ,EAAM,IAAN,CAER,EASW,EADX,EAAU,E,CAAV,EAC+B,EAAV,CAAV,CAPF,EAAI,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAFL,EAAI,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAG2C,EAAX,CAAX,CAAnC,G,IAGE,EAAO,GAAP,CAAJ,EAMa,EAFX,EAAU,E,CAAV,EAE+B,EAAV,CAAV,CAJF,EAAM,GAAN,CAGqC,EAAb,CAAV,KAAV,GACb,GALS,EAAM,GAAN,CAET,G,EAMS,EAAP,CAAJ,EAGa,EAFX,EAAU,EAEW,CAAU,EAAV,CAAV,CADsB,EAAc,EAAd,CAAV,KAAV,GACb,IAIW,EAFX,EAAU,EAEW,CAAU,EAAV,CAAV,CADe,EAAd,GACZ,I,QAgHS,CAAX,EACK,EAAS,EAAQ,EAAR,CAAT,CAAL,EASE,EAGa,EAFX,E,GAAA,EAE+B,EAAV,CAAV,CAA+C,EADlD,EAAM,EAAN,CAAR,EACoE,EAAJ,C,CAAZ,CAAyB,EAAzB,CAAP,KAAV,GAAnC,GACM,E,OAZY,EAAJ,CAAa,E,CAAjB,CAAZ,EACW,EAAO,EAAP,CAAX,EACA,EAEa,EADX,E,GAAA,EAC+B,EAAV,CAAV,CAA+C,EAAM,E,CAAZ,CAAqB,EAArB,CAAP,KAAV,GAAnC,GACA,EAAQ,E,CAAR,E,sDAuCC,EAAD,CAAJ,E,OAAmB,I,EAAP,G,IAGO,EAAD,C,EADN,EAAU,EAAV,CAAiB,EAAlB,CAAX,EACA,CAAU,EApPE,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,GAVX,EAyP8C,EAAZ,CAAiB,EAAlB,CAAwB,EAAjD,E,KACU,EAAyB,EAAzB,CAA+B,EAAO,EA5FjD,EAuGH,EAAJ,EAAqB,EAAwB,EAAnC,I,gBA7KV,EAAO,EAAO,KAAP,C,EAiBM,EADX,EAAU,E,CAAV,EAC+B,EAAV,CAAV,CAfK,EADR,EAAM,KAAN,CAAR,EAC0B,KAAJ,C,CAAd,CAAR,EAIY,IAAJ,CAAR,EAIa,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAFL,EAAI,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAG2C,EAAX,CAAX,CAAnC,GAMW,EADX,EAAU,E,CAAV,EAC+B,EAAV,CAAV,CAlBH,EAAI,IAAJ,CAAR,EAGa,GAAJ,CAWuC,EAAb,CAAV,KAAf,GAVD,EAAI,GAAJ,CAWuC,EAAb,CAAV,KAAf,GAG+C,EAAX,CAAX,CAAnC,G,IAGa,E,EAAQ,CAAU,EAAjC,E,MAyiBW,EAAX,EAeQ,EAAQ,EAAR,CADC,EAEQ,EAAQ,E,EAAA,CAAnB,GACO,EAAP,EAUA,EAAc,MAAd,CADC,E,EAES,CAvrBZ,EAAQ,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,G,EA+qBS,EAAM,EAAO,EA3hB1B,GA+hBa,EAAM,EAFV,EAzqBJ,SAAR,CAAJ,EACM,EAAQ,OAAR,CAAJ,EACkB,EAAS,OAAb,CAAL,GAAsC,EAAS,MAAb,CAAlC,EAES,EAAS,QAAb,CAAL,GAAyC,EAAS,QAAb,CAArC,GAGL,EAAQ,UAAR,CAAJ,EACkB,EAAS,SAAb,CAAL,IAES,EAAS,WAAb,CAAL,GAA8C,EAAS,UAAb,CAA1C,GAgqBP,EA1gBG,GA8gBO,E,KJvfV,EAAJ,EAC+B,EAAM,EAAzB,CAAV,E,GAxOgC,EAAzB,CAyOU,EAAb,CAAJ,EACkB,I,YAElB,IACW,EA1MA,E,GAAX,EACA,EAAqB,EAA0B,EAA1B,C,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,IAwMP,E,KAMF,EAAD,CAAJ,EAAU,EACmB,EAAM,EAAzB,CAAV,E,GAtPkC,EAAzB,CAuPQ,EAAb,CAAJ,EACkB,I,YAEd,EAAS,EAAT,CAAJ,EAIE,KAEA,IACW,EA9NA,E,GAAX,EA8NA,EA7NqB,EA6NC,EA7ND,C,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,OAkOV,EAAQ,EAAR,CAAJ,EAEE,EAAO,E,aAIT,EAAO,E,WACa,C,GAAA,CAA0B,G,CAAlC,CAAyC,GAAzC,CAAZ,E,yDkD5VE,E,KAAW,E,yEAQX,E,KAAW,E,UAAW,EAAX,C,KACP,E,QAAW,EAAX,CAAJ,E,EACE,E,KAAW,E,UACJ,EAAP,G,OAEK,G,8DATA,E,iExB0MmB,E,QAA1B,E,EACgC,E,QAAhC,EAEE,E,EACuB,E,GAAb,E,KAAkC,EAA5B,CAAN,CAAV,EACA,EAAa,EAAN,G,EACO,E,GACa,EAAnB,CAAF,CAAJ,EAQgC,EAGb,GAAR,GAGX,EAAO,E,CAAP,E,IAGI,EAAR,E,qQLuIY,EAAyB,EAA0B,EAA7C,C,GAAN,CAAV,EACA,EAAO,EAAM,EAAN,C,EACiB,EAAZ,GAAV,EACA,EAAiB,EAAR,GACT,EAAO,E,CAAP,E,kHRuHQ,E,QAAV,E,EACwB,E,GAAd,E,KAA8B,EAAvB,CAAP,CAAV,EACA,EAAO,EAAM,EAAN,C,EACiB,EAAZ,GAAV,EACA,EAAiB,EAAR,GACT,EAAO,E,CAAP,E,gCwCreI,E,QAAR,E,oGxCwe0B,E,QAA1B,E,mCbrdF,GAAsB,G,GACtB,GAAa,G,GACN,G,EAFP,GAAsB,G,GACtB,GAAa,G,GACN,G,EAFP,GAAsB,G,GACtB,GAAa,G,GACN,G,yKCnBE,E,YAMA,E,YAIA,E,YACA,E,0DAxBG,E,OACV,E,KAAM,E,KACN,E,KAAM,E,KACN,E,KAAM,E,KACN,E,KAAM,E,UACC,E,4COoIA,E,qEA2DyB,E,KAi2CxB,E,KAAA,EAAV,E,EAKmC,EAAoB,EAA7C,E,OACkB,E,GACf,E,KADb,EACA,GACO,EAAwB,EAAK,EAApC,E,EACqC,E,GAAxB,E,KA12C2B,EAk2CxB,EAAR,GAAsB,EAAN,G,SAAJ,EAA0B,EAAO,E,KAAX,EAA1C,EAQqC,CAArC,GACW,EARH,EAAQ,EAAR,GAAsB,EAAN,G,SAAJ,EAA0B,EAAO,E,KAAX,E,EACzB,E,KAAT,CAOkC,EAAN,CAApC,G,OACO,E,4CAl6CkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cAC7C,E,GAAiB,E,KAAjB,CAAT,G,sDPjBI,E,OAAe,EAAqB,EAAM,EAAd,EAAN,IAAtB,E,OACgB,E,OAAA,CAAH,SSohCjB,CTphCG,EAAZ,EACU,EAAV,E,EACyB,EAAJ,G,IACR,E,GAAX,E,EAAgB,EAAT,EAAiB,EAAI,EAAJ,CAAjB,C,CAAP,EAD4B,E,GAAA,E,IAKL,GAAO,EADpB,I,EAAU,K,EAAK,EAAM,EAAN,CAAL,EAAgB,GAAhB,EAAuB,GAC9B,CAAf,E,EACuB,EAAI,EAAJ,C,EACrB,EAAO,EAAW,EAAI,EAAJ,CAAX,C,CAAP,EAD4B,E,GAAA,E,WAGvB,E,4CA9FsB,E,KAAM,EAAG,EAAnB,EAAyB,EAAG,EAAG,EAAzC,E,wGAkEC,E,YACA,E,iBAQV,E,KAHY,EAAO,EAAP,C,KAIZ,E,KAHY,E,IAAQ,EAAR,C,UAIL,E,gEA3FW,E,OAAK,EAAL,EAAR,E,OACqB,E,QAAA,CAAH,SSonCnB,CTpnCK,EAA0B,EAA1B,CAAd,E,EACwB,E,KAAM,EAAG,EAAnB,E,EACW,EAAV,G,EAAgB,EAAO,EAAvB,EACiB,EAAG,EAA5B,E,mDAae,E,KAAM,EAAb,E,qDAOY,E,KAAK,EAAL,EAAR,E,WAAA,G,EAAgC,EAAV,G,EAAgB,EAAG,EAAnB,EAAyB,EAAG,EAA5D,E,sEO6Ia,E,GAAc,M,uEP3CtB,E,KAAK,EAAT,E,EACC,E,KAAK,EAAT,EAAgB,EAAhB,C,GACI,E,KAAK,EAAT,EAAgB,EAAhB,C,GACI,E,KAAK,EAAT,EAAgB,EAAhB,C,uDAjGa,E,KAAK,EAAL,EAAR,E,WAGO,G,EAFG,E,SAAc,EAAd,E,WAAV,E,EACU,E,SAAc,EAAd,E,WAAV,EACgB,EAAnB,E,sDAIW,E,OAAK,EAAL,EAAR,E,OACqB,E,QAAA,CAAH,SSilCrB,CTjlCO,EAA0B,EAA1B,CAAd,E,EACuB,E,KAAM,EAAG,EAAnB,EAAb,E,EACuB,E,KAAM,EAAO,EAAvB,EAAb,E,EACiB,E,KAAA,GAAO,EAAM,EAAM,EAA7B,E,mDAYW,E,OAAK,EAAL,EAAR,E,OACO,E,KAAA,G,EAAO,K,EAAA,GAAO,EAAG,EAA3B,E,qDAIW,E,OAAK,EAAL,EAAR,E,OACO,E,KAAA,G,EAAO,K,EAAA,G,EAAiB,EAAV,G,EAAgB,EAAG,EAAnB,EAAyB,EAAjD,E,6DASW,E,OAAK,EAAL,EAAR,E,SACY,E,SAAc,EAAd,E,WAA4B,EAAM,EAAN,CAAU,EAApB,EAAM,EAAN,EAAzB,I,YACE,G,EAAO,K,EAAA,G,cAAiB,E,QAAlC,E,6DAIW,E,OAAK,EAAL,EAAR,E,OACQ,E,OAAK,EAAL,EAAR,E,cACO,G,EAAO,K,EAAA,G,EAAO,K,EAAA,GAAO,EAA/B,E,sDYhHgB,E,GACrB,E,KADJ,EAC8B,EAAhB,CAAV,CAAJ,EACM,EAAU,MAAkB,EAAlB,CAAV,CAAJ,EAAgE,I,cAChC,E,QAAhC,E,EAGsB,E,KAAJ,CAA0B,EAA1B,CAAlB,EACI,EAAJ,E,MAAmC,EAAe,EAAf,C,WAAJ,C,EAAsC,E,KAA1C,CAAd,G,EACS,Eb4PiB,EAA5B,CAAb,E,GAE6B,EAAhB,CAAsB,EAAvB,C,EAAR,CAAJ,EACE,EAAgB,E,GACT,E,EAAP,GAIiB,EAAM,E,GAAZ,EAAb,EACoB,EAAY,EAAM,E,UAAV,CAA5B,KarQE,EAMe,EAAX,CAAJ,EACe,EAAO,EAApB,GACa,EAAO,EAApB,GACO,EAAO,EAA4B,EAA1C,GAES,EAAO,EAAlB,I,sDA6FuB,E,GAAnB,E,KAAA,CAAJ,EACM,EAAQ,EAAR,CAAJ,EAAoC,G,aACrB,EAAyB,EAAQ,EAAR,GAAW,EApH6B,EAoHhF,E,EACA,E,KAAe,E,MAER,E,QAAkB,EAAgB,EAAhB,CAAlB,CAAiD,EAA1D,G,gvIGtHiB,E,YACC,E,YACP,E,oKCCP,EAAc,MAAd,CAAJ,EAAyE,I,cACrB,EAAqB,EAA5D,E,OAIb,E,KAAc,E,oBACd,E,KAAiB,E,KACjB,E,KAAkB,E,+TIoDK,E,GAAnB,E,EAjBgD,EAA7C,C,GAAwE,EAAxE,CAiBH,CAAJ,EAAyD,G,aACrC,EAA2B,EAAgB,EAAhB,CAA3B,CAAR,G,mDAcW,E,GAAnB,E,EAhCgD,EAA7C,C,GAAwE,EAAxE,CAgCH,CAAJ,EAAyD,G,eACzD,E,KAAY,EAIwC,EAAhB,CAA3B,CAJU,EAInB,G,6FH3EiB,E,YACD,E,YACL,E,YACI,E,YACD,E,kECrBhB,E,KAAS,E,KAAA,G,IAAuB,E,KAAS,E,KC6EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7EM,G,EC6EgB,CAAlD,EAAK,EAAL,ED7EyB,EAAZ,CAApB,ED8CO,E,6DCxCP,E,KAAS,E,KAAA,G,IAA2B,E,KAAS,E,KCuEV,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvEU,G,ECuEY,CAAlD,EAAK,EAAL,E,EDvEyB,CAAZ,CAAY,CAAhC,EDwCO,E,6DClCP,E,KAAS,E,KAAA,G,IAAoB,E,KAAS,E,KCiEH,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDjEG,G,ECiEmB,CAAlD,EAAK,EAAL,EDjEsB,EAAT,CAApB,EDkCO,E,6DC5BP,E,KAAS,E,KAAA,G,IAAwB,E,KAAS,E,KC2DP,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED3DO,G,EC2De,CAAlD,EAAK,EAAL,E,ED3DsB,CAAT,CAAS,CAA7B,ED4BO,E,6DCtBP,E,KAAS,E,KAAA,G,IAAoB,E,KAAS,E,KCqDH,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDrDG,G,ECqDmB,CAAlD,EAAK,EAAL,EDrDsB,EAAT,CAApB,EDsBO,E,6DChBP,E,KAAS,E,KAAA,G,IAAwB,E,KAAS,E,KC+CP,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED/CO,G,EC+Ce,CAAlD,EAAK,EAAL,E,ED/CsB,CAAT,CAAS,CAA7B,EDgBO,E,6DCVP,E,KAAS,E,KAAA,G,IAA2B,E,KAAS,E,KCyCV,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDzCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAG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AAc,E,KAAA,G,IAAW,E,KLkBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTuIO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDS/IM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/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J,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EbyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GazDb,Gf+BK,E,6DexBH,E,KAAc,E,KbuDiB,E,EavDjB,G,EbuDuC,CAAlD,EAAK,EAAL,EavDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EatDM,G,EbsDgB,CAAlD,EAAK,EAAL,EatDoB,EAAzB,GfuBK,E,6DehBH,E,KAAc,E,Kb+CiB,E,Ea/CjB,G,Eb+CuC,CAAlD,EAAK,EAAL,Ea/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea9CM,G,Eb8CgB,CAAlD,EAAK,EAAL,Ea9CoB,EAAzB,GfeK,E,6DgB9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,Kd6EL,E,Ec7EK,G,Ed6EiB,CAAlD,EAAK,EAAL,Ec7EwB,E,IAAiC,EdwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,Ec7EwB,E,EdwEhB,GcvBN,CAjDT,EhB8CO,E,6DgBxCP,E,YAAS,G,IAAoC,E,KdkE9B,G,IclEuC,E,KAAS,E,KduE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EcvE4B,G,EduEN,CAAlD,EAAK,EAAL,EcvE+C,EA2C7C,CA3CT,EhBwCO,E,6DgBlCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdiE1B,E,EcjE0B,G,EdiEJ,CAAlD,EAAK,EAAL,E,EcjEyC,C,IAA4B,EAyCtD,G,EdwBa,E,EAAsB,CAAlD,EAAK,EAAL,EcjEyC,E,EAyC1B,GAAb,CdmBF,Cc5DP,EhBkCO,E,6DgB5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,Kd2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EcxBY,E,EdwBgB,E,Ec3DuC,G,Ed2DjB,CAAlD,EAAK,EAAL,E,Ec3DsD,CAmCpD,CdmBF,CctDP,EhB4BO,E,6DgBtBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdqDL,E,EcrDK,G,EdqDiB,CAAlD,EAAK,EAAL,EcrDwB,E,IAAmB,E,KAAS,E,KdqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EcrDwB,E,EdqDI,E,EcrDwB,G,EdqDF,CAAlD,EAAK,EAAL,EcrD2C,EAiCzC,CAjCT,EhBsBO,E,6DgBhBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,Kd+C1B,E,Ec/C0B,G,Ed+CJ,CAAlD,EAAK,EAAL,E,Ec/CyC,C,IAA4B,E,KAAS,E,Kd+ClD,E,EAAsB,CAAlD,EAAK,EAAL,Ec/CyC,E,Ed+Cb,E,Ec/CkD,G,Ed+C5B,CAAlD,EAAK,EAAL,E,Ec/CiE,CA+B/D,CdWF,Cc1CP,EhBgBO,E,6DgBVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdyCL,E,EczCK,G,EdyCiB,CAAlD,EAAK,EAAL,EczCwB,E,IAAmB,E,KAAS,E,KdyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EczCwB,E,EdyCI,E,EczCwB,G,EdyCF,CAAlD,EAAK,EAAL,EczC2C,EAazC,CAbT,EhBUO,E,6DgBJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdmC1B,E,EcnC0B,G,EdmCJ,CAAlD,EAAK,EAAL,E,EcnCyC,C,IAA4B,E,KAAS,E,KdmClD,E,EAAsB,CAAlD,EAAK,EAAL,EcnCyC,E,EdmCb,E,EcnCkD,G,EdmC5B,CAAlD,EAAK,EAAL,E,EcnCiE,CAW/D,CdmBF,Cc9BP,EhBIO,E,sDiB9CM,E,Yf6EsB,E,Ee7ER,G,Ef6E8B,CAAlD,EAAK,EAAL,Ee7EM,E,EAA2C,EfwEzC,G,EAAA,GexEF,CAAb,E,EACA,E,KAAc,E,Kf4EqB,E,Ee5ErB,G,Ef4E2C,CAAlD,EAAK,EAAL,Ee5EkB,GAAzB,EjB6CO,E,sDiBvCU,E,YfsEkB,E,EetEJ,G,EfsE0B,CAAlD,EAAK,EAAL,EetEM,E,EAA4C,EfiE1C,G,EAAA,GejEF,CAAb,E,EACA,E,KAAc,E,KfqEqB,E,EerErB,G,EfqE2C,CAAlD,EAAK,EAAL,EerEkB,GAAzB,EjBsCO,E,sDiBhCM,E,Yf+DsB,E,Ee/DR,G,Ef+D8B,CAAlD,EAAK,EAAL,Ee/DM,E,EAA2C,Ef0DzC,G,EAAA,Ge1DF,CAAb,E,EACA,E,KAAc,E,Kf8DqB,E,Ee9DrB,G,Ef8D2C,CAAlD,EAAK,EAAL,Ee9DkB,GAAzB,EjB+BO,E,sDiBzBU,E,YfwDkB,E,EexDJ,G,EfwD0B,CAAlD,EAAK,EAAL,EexDM,E,EAA4C,EfmD1C,G,EAAA,GenDF,CAAb,E,EACA,E,KAAc,E,KfuDqB,E,EevDrB,G,EfuD2C,CAAlD,EAAK,EAAL,EevDkB,GAAzB,EjBwBO,E,6DiBlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KfiDJ,E,EejDI,G,EfiDkB,CAAlD,EAAK,EAAL,EejDkB,E,IAAyB,E,KAAc,E,KfiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EejD6B,G,EfiDP,CAAlD,EAAK,EAAL,EejD2C,EAAzB,IAAzB,EjBkBO,E,6DiBZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kf2CR,E,Ee3CQ,G,Ef2Cc,CAAlD,EAAK,EAAL,Ee3CkB,E,IAAkC,E,KAAc,E,Kf2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ee3CsC,G,Ef2ChB,CAAlD,EAAK,EAAL,Ee3CgD,EAA9B,IAAzB,EjBYO,E,wDkB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhByEG,E,EgBzEH,G,EhByEyB,CAAlD,EAAK,EAAL,E,EgBzEO,CAAd,E,EACA,E,KAAc,E,KhBwEqB,E,EgBxErB,G,EhBwE2C,CAAlD,EAAK,EAAL,EgBxEgC,EAAS,EAAT,ChBmEhC,CgBnEP,ElByCO,E,wDkBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBiEG,E,EgBjEH,G,EhBiEyB,CAAlD,EAAK,EAAL,E,EgBjEO,CAAd,E,EACA,E,KAAc,E,KhBgEqB,E,EgBhErB,G,EhBgE2C,CAAlD,EAAK,EAAL,EgBhEgC,EAAU,EAAV,ChB2DhC,CgB3DP,ElBiCO,E,sDkB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KhByDX,E,EgBzDW,G,EhByDW,CAAlD,EAAK,EAAL,E,EgBzDqB,CAA5B,E,EACA,E,KAAc,E,KhBwDqB,E,EgBxDrB,G,EhBwD2C,CAAlD,EAAK,EAAL,EgBxDkB,E,EAAS,CAAT,CAAzB,ElByBO,E,sDkBnBW,E,KAAc,E,KhBkDG,E,EgBlDH,G,EhBkDyB,CAAlD,EAAK,EAAL,EgBlDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhBiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgBjD0C,EAAV,ChB4ChC,CgB5CP,ElBkBO,E,sDkBZW,E,KAAc,E,KhB2CG,E,EgB3CH,G,EhB2CyB,CAAlD,EAAK,EAAL,EgB3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhB0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgB1C2C,EAAX,ChBqChC,CgBrCP,ElBWO,E,sDkBLW,E,YhBoCiB,E,EgBpCH,G,EhBoCyB,CAAlD,EAAK,EAAL,EgBpCW,E,GAAJ,CAAd,E,EAC0B,E,KhB8BX,GgB9Bf,E,EACA,E,KAAc,E,KhBkCqB,E,EgBlCrB,G,EhBkC2C,CAAlD,EAAK,EAAL,EgBlCoC,E,EAAO,C,CAAX,CAAvC,ElBGO,E,6DkBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhB2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgB3BI,G,EhB2BkB,CAAlD,EAAK,EAAL,EgB3BkB,E,EAA0B,CAA1B,CAAzB,ElBJO,E,6DkBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBpBI,G,EhBoBkB,CAAlD,EAAK,EAAL,EgBpBkB,E,EAA2B,CAA3B,CAAzB,ElBXO,E,sDkBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBaG,E,EgBbH,G,EhBayB,CAAlD,EAAK,EAAL,EgBbO,EAAd,E,EACA,E,KAAc,E,KhBYqB,E,EgBZrB,G,EhBY2C,CAAlD,EAAK,EAAL,EgBZkB,E,EAAS,CAAT,CAAzB,ElBnBO,E,sDkByBW,E,KAAc,E,KhBMG,E,EgBNH,G,EhBMyB,CAAlD,EAAK,EAAL,EgBNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBAmC,CAAzB,CAAzB,ElB1BO,E,sDkBgCW,E,KAAc,E,KhBDG,E,EgBCH,G,EhBDyB,CAAlD,EAAK,EAAL,EgBCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBOoC,CAA1B,CAAzB,ElBjCO,E,sDkBuCW,E,YhBRiB,E,EgBQH,G,EhBRyB,CAAlD,EAAK,EAAL,EgBQW,E,GAAJ,CAAd,E,EAC4B,E,KhBdb,GgBcf,E,EACA,E,KAAc,E,KhBVqB,E,EgBUrB,G,EhBV2C,CAAlD,EAAK,EAAL,EgBUoC,E,EAAS,C,CAAb,CAAvC,ElBzCO,E,wDkB+CW,E,KAAc,E,KhBhBG,E,EgBgBH,G,EhBhByB,CAAlD,EAAK,EAAL,EgBgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBjBG,E,EgBiBH,G,EhBjByB,CAAlD,EAAK,EAAL,E,EgBiBO,CAAd,E,EACA,E,KAAc,E,KhBlBqB,E,EgBkBrB,G,EhBlB2C,CAAlD,EAAK,EAAL,EgBkBgC,EAAS,EAAT,ChBvBhC,CgBuBP,ElBjDO,E,wDkBuDW,E,KAAc,E,KhBxBG,E,EgBwBH,G,EhBxByB,CAAlD,EAAK,EAAL,EgBwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBzBG,E,EgByBH,G,EhBzByB,CAAlD,EAAK,EAAL,E,EgByBO,CAAd,E,EACA,E,KAAc,E,KhB1BqB,E,EgB0BrB,G,EhB1B2C,CAAlD,EAAK,EAAL,EgB0BgC,EAAU,EAAV,ChB/BhC,CgB+BP,ElBzDO,E,sDkB+DW,E,KAAc,E,KhBhCG,E,EgBgCH,G,EhBhCyB,CAAlD,EAAK,EAAL,EgBgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KhBjCd,E,EgBiCc,G,EhBjCQ,CAAlD,EAAK,EAAL,E,EgBiCwB,CAA/B,E,EACA,E,KAAc,E,KhBlCqB,E,EgBkCrB,G,EhBlC2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ByBuB,CAAlD,EAAK,EAAL,EiBzBa,E,EAAuC,EjBoB5C,G,EAAA,G,CiBpBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YjBkBe,E,EiBlBD,G,EjBkBuB,CAAlD,EAAK,EAAL,EiBlBa,E,EAAuC,EjBa5C,G,EAAA,G,CiBbC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YjBWe,E,EiBXD,G,EjBWuB,CAAlD,EAAK,EAAL,EiBXa,E,EAAuC,EjBM5C,G,EAAA,G,CiBNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YjBIe,E,EiBJD,G,EjBIuB,CAAlD,EAAK,EAAL,EiBJa,E,EAAuC,EjBD5C,G,EAAA,G,CiBCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBFjB,GiBEG,G,OACD,E,KAAV,E,+DAKa,E,YjBHe,E,EiBGD,G,EjBHuB,CAAlD,EAAK,EAAL,EiBGa,E,EAAuC,EjBR5C,G,EAAA,G,CiBQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EjBJQ,E,EiBIoB,G,EjBJE,CAAlD,EAAK,EAAL,EiBIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YjBVe,E,EiBUD,G,EjBVuB,CAAlD,EAAK,EAAL,EiBUa,E,EAAuC,EjBf5C,G,EAAA,G,CiBeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EjBXO,E,EiBWsB,G,EjBXA,CAAlD,EAAK,EAAL,EiBWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBjBe,E,EiBiBD,G,EjBjBuB,CAAlD,EAAK,EAAL,EiBiBa,E,EAAuC,EjBtB5C,G,EAAA,G,CiBsBC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA3B,E,EjBlBO,E,EiBkBoB,G,EjBlBE,CAAlD,EAAK,EAAL,E,EiBkB8B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBxBe,E,EiBwBD,G,EjBxBuB,CAAl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K,EAAL,EoBiOU,E,QAab,E,KAAa,E,KAAc,E,OpB9OI,E,EoB8OJ,G,EpB9O0B,CAAlD,EAAK,EAAL,EoB8OU,E,KACb,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAA2B,E,OpBrPhB,G,KoBsPX,E,KAA2B,E,OpBtPhB,G,QoByPX,E,KAAa,E,KAAc,E,OpBpPI,E,EoBoPJ,G,EpBpP0B,CAAlD,EAAK,EAAL,EoBoPU,E,KACb,E,KAAa,E,KAAc,E,OpBrPI,E,EoBqPJ,G,EpBrP0B,CAAlD,EAAK,EAAL,EoBqPU,E,KACb,E,KAAa,E,KAAc,E,OpBtPI,E,EoBsPJ,G,EpBtP0B,CAAlD,EAAK,EAAL,EoBsPU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBzMhB,G,QoB6MX,E,KAA2B,E,OpB7MhB,G,QoB2NX,E,KAAa,E,KAAc,E,OpBtNI,E,EoBsNJ,G,EpBtN0B,CAAlD,EAAK,EAAL,EoBsNU,E,KACb,E,KAA2B,E,OpB5NhB,G,QoByOX,E,KAAa,E,KAAc,E,OpBpOI,E,EoBoOJ,G,EpBpO0B,CAAlD,EAAK,EAAL,EoBoOU,E,KACb,E,KAAa,E,KAAc,E,OpBrOI,E,EoBqOJ,G,EpBrO0B,CAAlD,EAAK,EAAL,EoBqOU,E,MAbb,E,KAA2B,E,OpB7NhB,G,WoBuMJ,E,6CKnMoB,G,SACjB,E,wCnBkHkB,E,QAA9B,E,EACW,E,QAAX,E,6GbhII,EAAc,MAAd,CAAJ,EAA4E,I,iBAEvD,E,KAAJ,CAAgC,EAAhC,CAAjB,EACuD,EAA1C,E,OAIb,E,KAAc,E,oBACd,E,KAAiB,E,KACjB,E,KAAkB,E,KAClB,E,KAAe,E,iBayHC,EAAI,EAAJ,C,EACwB,EAAQ,EAAW,EAAX,CAAlC,CAAZ,E,GACyB,EAAnB,C,CAAN,E,EACY,E,KAAK,EAAY,E,GAA3B,E,KADF,GAF0B,E,GAAF,E,MAM1B,E,KAAc,EAAd,G,YmB3HsC,EAAxC,E,WACoB,GAAJ,G,IACE,E,KAAM,EAAN,GAAhB,E,EACa,E,mBAAiB,EAAjB,E,OAGT,E,sBAIS,E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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/release.wat b/build/release.wat index 4de45a6..6cd838e 100644 --- a/build/release.wat +++ b/build/release.wat @@ -2,27 +2,31 @@ (type $0 (func (param i32 i32 i32) (result i32))) (type $1 (func (param i32 i32) (result i32))) (type $2 (func (param i32) (result i32))) - (type $3 (func (result i32))) - (type $4 (func (param i32))) - (type $5 (func (param i32 i32))) - (type $6 (func (param i32 i32 i32))) + (type $3 (func (param i32))) + (type $4 (func (result i32))) + (type $5 (func (param i32 i32 i32))) + (type $6 (func (param i32 i32))) (type $7 (func (param i32 i32 i32 i32) (result i32))) (type $8 (func)) (type $9 (func (param i32 i32 i32 i32))) (type $10 (func (param i32 i32 i64))) (type $11 (func (param i32 i64) (result i32))) - (type $12 (func (param i64 i32 i32) (result i32))) - (type $13 (func (param i64) (result i32))) - (type $14 (func (param i32 i32 i32 i32 i64))) - (type $15 (func (param i32 i64 i32 i32))) - (type $16 (func (param i32 i64 i32))) - (type $17 (func (param i32 i64))) - (type $18 (func (param i32) (result i64))) - (type $19 (func (param i32 i32) (result i64))) - (type $20 (func (param i32 i32 i64) (result i32))) - (type $21 (func (result i64))) - (type $22 (func (param i64))) - (type $23 (func (param i64 i32) (result i32))) + (type $12 (func (param i64) (result i32))) + (type $13 (func (param i32 i32 i32 i32 i64 i32))) + (type $14 (func (param i32 i32 i32 i32 i32 i32 i32) (result i32))) + (type $15 (func (param i64 i32 i32) (result i32))) + (type $16 (func (param i32 i64 i32 i32 i32) (result i32))) + (type $17 (func (param i32 i64 i32 i32))) + (type $18 (func (param i32 i64 i32))) + (type $19 (func (param i32 i64))) + (type $20 (func (param i32) (result i64))) + (type $21 (func (param i32 i32) (result i64))) + (type $22 (func (param i32 i32 i64) (result i32))) + (type $23 (func (result i64))) + (type $24 (func (param i64))) + (type $25 (func (param i64 i32) (result i32))) + (type $26 (func (param i32 f64 i64 i32 i32))) + (type $27 (func (param i32 i32 i64 i32))) (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) @@ -42,13 +46,13 @@ (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) - (global $assembly/api/interpreter (mut i32) (i32.const 0)) - (global $assembly/index/InputKind.Generic i32 (i32.const 0)) - (global $assembly/index/InputKind.SPI i32 (i32.const 1)) - (global $assembly/index/HasMetadata.Yes i32 (i32.const 0)) - (global $assembly/index/HasMetadata.No i32 (i32.const 1)) - (global $~lib/rt/__rtti_base i32 (i32.const 21056)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 54068)) + (global $assembly/api-debugger/interpreter (mut i32) (i32.const 0)) + (global $assembly/api-utils/InputKind.Generic i32 (i32.const 0)) + (global $assembly/api-utils/InputKind.SPI i32 (i32.const 1)) + (global $assembly/api-utils/HasMetadata.Yes i32 (i32.const 0)) + (global $assembly/api-utils/HasMetadata.No i32 (i32.const 1)) + (global $~lib/rt/__rtti_base i32 (i32.const 21504)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 54532)) (memory $0 1) (data $0 (i32.const 1036) "L") (data $0.1 (i32.const 1048) "\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03") @@ -569,120 +573,120 @@ (data $260.1 (i32.const 12376) "\14\00\00\00\08\00\00\00b") (data $261 (i32.const 12396) "\1c") (data $261.1 (i32.const 12408) "\14\00\00\00\08\00\00\00c") - (data $262 (i32.const 12428) "\1c") - (data $262.1 (i32.const 12440) "\14\00\00\00\08\00\00\00d") - (data $263 (i32.const 12460) "\1c") - (data $263.1 (i32.const 12472) "\14\00\00\00\08\00\00\00e") - (data $264 (i32.const 12492) "\1c") - (data $264.1 (i32.const 12504) "\14\00\00\00\08\00\00\00f") - (data $265 (i32.const 12524) "\1c") - (data $265.1 (i32.const 12536) "\14\00\00\00\08\00\00\00g") - (data $266 (i32.const 12556) "\1c") - (data $266.1 (i32.const 12568) "\14\00\00\00\08\00\00\00h") - (data $267 (i32.const 12588) "\1c") - (data $267.1 (i32.const 12600) "\14\00\00\00\08\00\00\00i") - (data $268 (i32.const 12620) "\1c") - (data $268.1 (i32.const 12632) "\14\00\00\00\08\00\00\00j") - (data $269 (i32.const 12652) "\1c") - (data $269.1 (i32.const 12664) "\14\00\00\00\08\00\00\00k") - (data $270 (i32.const 12684) "\1c") - (data $270.1 (i32.const 12696) "\14\00\00\00\08\00\00\00l") - (data $271 (i32.const 12716) "\1c") - (data $271.1 (i32.const 12728) "\14\00\00\00\08\00\00\00m") - (data $272 (i32.const 12748) "\1c") - (data $272.1 (i32.const 12760) "\14\00\00\00\08\00\00\00n") - (data $273 (i32.const 12780) "\1c") - (data $273.1 (i32.const 12792) "\14\00\00\00\08\00\00\00o") - (data $274 (i32.const 12812) "\1c") - (data $274.1 (i32.const 12824) "\14\00\00\00\08\00\00\00p") - (data $275 (i32.const 12844) "\1c") - (data $275.1 (i32.const 12856) "\14\00\00\00\08\00\00\00q") - (data $276 (i32.const 12876) "\1c") - (data $276.1 (i32.const 12888) "\14\00\00\00\08\00\00\00r") - (data $277 (i32.const 12908) "\1c") - (data $277.1 (i32.const 12920) "\14\00\00\00\08\00\00\00s") - (data $278 (i32.const 12940) "\1c") - (data $278.1 (i32.const 12952) "\14\00\00\00\08\00\00\00t") - (data $279 (i32.const 12972) "\1c") - (data $279.1 (i32.const 12984) "\14\00\00\00\08\00\00\00u") - (data $280 (i32.const 13004) "\1c") - (data $280.1 (i32.const 13016) "\14\00\00\00\08\00\00\00v") - (data $281 (i32.const 13036) "\1c") - (data $281.1 (i32.const 13048) "\14\00\00\00\08\00\00\00w") - (data $282 (i32.const 13068) "\1c") - (data $282.1 (i32.const 13080) "\14\00\00\00\08\00\00\00x") - (data $283 (i32.const 13100) "\1c") - (data $283.1 (i32.const 13112) "\14\00\00\00\08\00\00\00y") - (data $284 (i32.const 13132) "\1c") - (data $284.1 (i32.const 13144) "\14\00\00\00\08\00\00\00z") - (data $285 (i32.const 13164) "\1c") - (data $285.1 (i32.const 13176) "\14\00\00\00\08\00\00\00{") - (data $286 (i32.const 13196) "\1c") - (data $286.1 (i32.const 13208) "\14\00\00\00\08\00\00\00|") - (data $287 (i32.const 13228) "\1c") - (data $287.1 (i32.const 13240) "\14\00\00\00\08\00\00\00}") - (data $288 (i32.const 13260) "\1c") - (data $288.1 (i32.const 13272) "\14\00\00\00\08\00\00\00~") - (data $289 (i32.const 13292) "\1c") - (data $289.1 (i32.const 13304) "\14\00\00\00\08\00\00\00\7f") - (data $290 (i32.const 13324) "\1c") - (data $290.1 (i32.const 13336) "\14\00\00\00\08\00\00\00\80") - (data $291 (i32.const 13356) "\1c") - (data $291.1 (i32.const 13368) "\14\00\00\00\08\00\00\00\81") - (data $292 (i32.const 13388) "\1c") - (data $292.1 (i32.const 13400) "\14\00\00\00\08\00\00\00\82") - (data $293 (i32.const 13420) "\1c") - (data $293.1 (i32.const 13432) "\14\00\00\00\08\00\00\00\83") - (data $294 (i32.const 13452) "\1c") - (data $294.1 (i32.const 13464) "\14\00\00\00\08\00\00\00\84") - (data $295 (i32.const 13484) "\1c") - (data $295.1 (i32.const 13496) "\14\00\00\00\08\00\00\00\85") - (data $296 (i32.const 13516) "\1c") - (data $296.1 (i32.const 13528) "\14\00\00\00\08\00\00\00\86") - (data $297 (i32.const 13548) "\1c") - (data $297.1 (i32.const 13560) "\14\00\00\00\08\00\00\00\87") - (data $298 (i32.const 13580) "\1c") - (data $298.1 (i32.const 13592) "\14\00\00\00\08\00\00\00\88") - (data $299 (i32.const 13612) "\1c") - (data $299.1 (i32.const 13624) "\14\00\00\00\08\00\00\00\89") - (data $300 (i32.const 13644) "\1c") - (data $300.1 (i32.const 13656) "\14\00\00\00\08\00\00\00\8a") - (data $301 (i32.const 13676) "\1c") - (data $301.1 (i32.const 13688) "\14\00\00\00\08\00\00\00\8b") - (data $302 (i32.const 13708) "\1c") - (data $302.1 (i32.const 13720) "\14\00\00\00\08\00\00\00\8c") - (data $303 (i32.const 13740) "\1c") - (data $303.1 (i32.const 13752) "\14\00\00\00\08\00\00\00\8d") - (data $304 (i32.const 13772) "\1c") - (data $304.1 (i32.const 13784) "\14\00\00\00\08\00\00\00\8e") - (data $305 (i32.const 13804) "\1c") - (data $305.1 (i32.const 13816) "\14\00\00\00\08\00\00\00\8f") - (data $306 (i32.const 13836) "\1c") - (data $306.1 (i32.const 13848) "\14\00\00\00\08\00\00\00\90") - (data $307 (i32.const 13868) "\1c") - (data $307.1 (i32.const 13880) "\14\00\00\00\08\00\00\00\91") - (data $308 (i32.const 13900) "\1c") - (data $308.1 (i32.const 13912) "\14\00\00\00\08\00\00\00\92") - (data $309 (i32.const 13932) "\1c") - (data $309.1 (i32.const 13944) "\14\00\00\00\08\00\00\00\93") - (data $310 (i32.const 13964) "\1c") - (data $310.1 (i32.const 13976) "\14\00\00\00\08\00\00\00\94") - (data $311 (i32.const 13996) "\1c") - (data $311.1 (i32.const 14008) "\14\00\00\00\08\00\00\00\95") - (data $312 (i32.const 14028) "\1c") - (data $312.1 (i32.const 14040) "\14\00\00\00\08\00\00\00\96") - (data $313 (i32.const 14060) "\1c") - (data $313.1 (i32.const 14072) "\14\00\00\00\08\00\00\00\97") - (data $314 (i32.const 14092) "\1c") - (data $314.1 (i32.const 14104) "\14\00\00\00\08\00\00\00\98") - (data $315 (i32.const 14124) ",") - (data $315.1 (i32.const 14136) "\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y") - (data $316 (i32.const 14172) "\\") - (data $316.1 (i32.const 14184) "\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.") + (data $262 (i32.const 12428) ",") + (data $262.1 (i32.const 12440) "\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y") + (data $263 (i32.const 12476) "\\") + (data $263.1 (i32.const 12488) "\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.") + (data $264 (i32.const 12572) "\1c") + (data $264.1 (i32.const 12584) "\14\00\00\00\08\00\00\00d") + (data $265 (i32.const 12604) "\1c") + (data $265.1 (i32.const 12616) "\14\00\00\00\08\00\00\00e") + (data $266 (i32.const 12636) "\1c") + (data $266.1 (i32.const 12648) "\14\00\00\00\08\00\00\00f") + (data $267 (i32.const 12668) "\1c") + (data $267.1 (i32.const 12680) "\14\00\00\00\08\00\00\00g") + (data $268 (i32.const 12700) "\1c") + (data $268.1 (i32.const 12712) "\14\00\00\00\08\00\00\00h") + (data $269 (i32.const 12732) "\1c") + (data $269.1 (i32.const 12744) "\14\00\00\00\08\00\00\00i") + (data $270 (i32.const 12764) "\1c") + (data $270.1 (i32.const 12776) "\14\00\00\00\08\00\00\00j") + (data $271 (i32.const 12796) "\1c") + (data $271.1 (i32.const 12808) "\14\00\00\00\08\00\00\00k") + (data $272 (i32.const 12828) "\1c") + (data $272.1 (i32.const 12840) "\14\00\00\00\08\00\00\00l") + (data $273 (i32.const 12860) "\1c") + (data $273.1 (i32.const 12872) "\14\00\00\00\08\00\00\00m") + (data $274 (i32.const 12892) "\1c") + (data $274.1 (i32.const 12904) "\14\00\00\00\08\00\00\00n") + (data $275 (i32.const 12924) "\1c") + (data $275.1 (i32.const 12936) "\14\00\00\00\08\00\00\00o") + (data $276 (i32.const 12956) "\1c") + (data $276.1 (i32.const 12968) "\14\00\00\00\08\00\00\00p") + (data $277 (i32.const 12988) "\1c") + (data $277.1 (i32.const 13000) "\14\00\00\00\08\00\00\00q") + (data $278 (i32.const 13020) "\1c") + (data $278.1 (i32.const 13032) "\14\00\00\00\08\00\00\00r") + (data $279 (i32.const 13052) "\1c") + (data $279.1 (i32.const 13064) "\14\00\00\00\08\00\00\00s") + (data $280 (i32.const 13084) "\1c") + (data $280.1 (i32.const 13096) "\14\00\00\00\08\00\00\00t") + (data $281 (i32.const 13116) "\1c") + (data $281.1 (i32.const 13128) "\14\00\00\00\08\00\00\00u") + (data $282 (i32.const 13148) "\1c") + (data $282.1 (i32.const 13160) "\14\00\00\00\08\00\00\00v") + (data $283 (i32.const 13180) "\1c") + (data $283.1 (i32.const 13192) "\14\00\00\00\08\00\00\00w") + (data $284 (i32.const 13212) "\1c") + (data $284.1 (i32.const 13224) "\14\00\00\00\08\00\00\00x") + (data $285 (i32.const 13244) "\1c") + (data $285.1 (i32.const 13256) "\14\00\00\00\08\00\00\00y") + (data $286 (i32.const 13276) "\1c") + (data $286.1 (i32.const 13288) "\14\00\00\00\08\00\00\00z") + (data $287 (i32.const 13308) "\1c") + (data $287.1 (i32.const 13320) "\14\00\00\00\08\00\00\00{") + (data $288 (i32.const 13340) "\1c") + (data $288.1 (i32.const 13352) "\14\00\00\00\08\00\00\00|") + (data $289 (i32.const 13372) "\1c") + (data $289.1 (i32.const 13384) "\14\00\00\00\08\00\00\00}") + (data $290 (i32.const 13404) "\1c") + (data $290.1 (i32.const 13416) "\14\00\00\00\08\00\00\00~") + (data $291 (i32.const 13436) "\1c") + (data $291.1 (i32.const 13448) "\14\00\00\00\08\00\00\00\7f") + (data $292 (i32.const 13468) "\1c") + (data $292.1 (i32.const 13480) "\14\00\00\00\08\00\00\00\80") + (data $293 (i32.const 13500) "\1c") + (data $293.1 (i32.const 13512) "\14\00\00\00\08\00\00\00\81") + (data $294 (i32.const 13532) "\1c") + (data $294.1 (i32.const 13544) "\14\00\00\00\08\00\00\00\82") + (data $295 (i32.const 13564) "\1c") + (data $295.1 (i32.const 13576) "\14\00\00\00\08\00\00\00\83") + (data $296 (i32.const 13596) "\1c") + (data $296.1 (i32.const 13608) "\14\00\00\00\08\00\00\00\84") + (data $297 (i32.const 13628) "\1c") + (data $297.1 (i32.const 13640) "\14\00\00\00\08\00\00\00\85") + (data $298 (i32.const 13660) "\1c") + (data $298.1 (i32.const 13672) "\14\00\00\00\08\00\00\00\86") + (data $299 (i32.const 13692) "\1c") + (data $299.1 (i32.const 13704) "\14\00\00\00\08\00\00\00\87") + (data $300 (i32.const 13724) "\1c") + (data $300.1 (i32.const 13736) "\14\00\00\00\08\00\00\00\88") + (data $301 (i32.const 13756) "\1c") + (data $301.1 (i32.const 13768) "\14\00\00\00\08\00\00\00\89") + (data $302 (i32.const 13788) "\1c") + (data $302.1 (i32.const 13800) "\14\00\00\00\08\00\00\00\8a") + (data $303 (i32.const 13820) "\1c") + (data $303.1 (i32.const 13832) "\14\00\00\00\08\00\00\00\8b") + (data $304 (i32.const 13852) "\1c") + (data $304.1 (i32.const 13864) "\14\00\00\00\08\00\00\00\8c") + (data $305 (i32.const 13884) "\1c") + (data $305.1 (i32.const 13896) "\14\00\00\00\08\00\00\00\8d") + (data $306 (i32.const 13916) "\1c") + (data $306.1 (i32.const 13928) "\14\00\00\00\08\00\00\00\8e") + (data $307 (i32.const 13948) "\1c") + (data $307.1 (i32.const 13960) "\14\00\00\00\08\00\00\00\8f") + (data $308 (i32.const 13980) "\1c") + (data $308.1 (i32.const 13992) "\14\00\00\00\08\00\00\00\90") + (data $309 (i32.const 14012) "\1c") + (data $309.1 (i32.const 14024) "\14\00\00\00\08\00\00\00\91") + (data $310 (i32.const 14044) "\1c") + (data $310.1 (i32.const 14056) "\14\00\00\00\08\00\00\00\92") + (data $311 (i32.const 14076) "\1c") + (data $311.1 (i32.const 14088) "\14\00\00\00\08\00\00\00\93") + (data $312 (i32.const 14108) "\1c") + (data $312.1 (i32.const 14120) "\14\00\00\00\08\00\00\00\94") + (data $313 (i32.const 14140) "\1c") + (data $313.1 (i32.const 14152) "\14\00\00\00\08\00\00\00\95") + (data $314 (i32.const 14172) "\1c") + (data $314.1 (i32.const 14184) "\14\00\00\00\08\00\00\00\96") + (data $315 (i32.const 14204) "\1c") + (data $315.1 (i32.const 14216) "\14\00\00\00\08\00\00\00\97") + (data $316 (i32.const 14236) "\1c") + (data $316.1 (i32.const 14248) "\14\00\00\00\08\00\00\00\98") (data $317 (i32.const 14268) "\1c") (data $317.1 (i32.const 14280) "\14\00\00\00\08\00\00\00\99") (data $318 (i32.const 14300) "\ac\03") - (data $318.1 (i32.const 14312) "\01\00\00\00\9c\03\00\00\e06\00\00\007\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 7\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00`(\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c04\00\00\e04\00\00\005\00\00 5\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\e0\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\00(\00\00\80(\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\00`*\00\00\80*\00\00\a0*\00\00@5\00\00`5\00\00\805\00\00\a05\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c05\00\00\e05\00\00\006\00\00 6\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 (\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00\c0&\00\00\e0&\00\00\00\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 0\00\00\d07\00\00\a0$\00\00\c0$\00\00\e0$\00\00\00%\00\00 %\00\00@%\00\00`%\00\00\80%\00\00\a0%\00\00\c0%\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00@6\00\00`6\00\00\806\00\00\a06\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00@+\00\00`+\00\00\80+\00\00\c0,\00\00\a0+\00\00\c0+\00\00\e0+\00\00\e0,\00\00\c01\00\00\e01\00\00\802\00\00\a02\00\00\c02\00\00\00-\00\00\002\00\00 2\00\00\e02\00\00\003\00\00 3\00\00@0\00\00`0\00\00 -\00\00@-\00\00@3\00\00`3\00\00\803\00\00`-\00\00\a03\00\00\c03\00\00\e03\00\00\c00\00\00\e00\00\00\001\00\00 1\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\a0\'\00\00\c0\'\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00@(\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\c06\00\00\80-\00\00\a0-\00\00\c0-\00\00\e0-\00\00\00.\00\00 .\00\00@.\00\00\004\00\00 4\00\00@4\00\00`.\00\00\80.\00\00\a0.\00\00\c0.\00\00\e0.\00\00\00/\00\00 /\00\00`4\00\00\804\00\00\a04\00\00\00,\00\00 ,\00\00@,\00\00@/\00\00`/\00\00\80/\00\00@2\00\00`2\00\00\800\00\00\a00\00\00@1\00\00`1\00\00\801\00\00\a01\00\00`,\00\00\80,\00\00\a0,\00\00\a0/\00\00\c0/\00\00\e0/\00\00\000") + (data $318.1 (i32.const 14312) "\01\00\00\00\9c\03\00\00@0\00\00`0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\800\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00`(\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\f05\00\00\106\00\0006\00\00P6\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\e0\'\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\00(\00\00\80(\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\00`*\00\00\80*\00\00\a0*\00\00p6\00\00\906\00\00\b06\00\00\d06\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\f06\00\00\107\00\0007\00\00P7\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 (\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00\c0&\00\00\e0&\00\00\00\'\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00P1\00\0001\00\00\a0$\00\00\c0$\00\00\e0$\00\00\00%\00\00 %\00\00@%\00\00`%\00\00\80%\00\00\a0%\00\00\c0%\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00p7\00\00\907\00\00\b07\00\00\d07\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00@+\00\00`+\00\00\80+\00\00\c0,\00\00\a0+\00\00\c0+\00\00\e0+\00\00\e0,\00\00\f02\00\00\103\00\00\b03\00\00\d03\00\00\f03\00\00\00-\00\0003\00\00P3\00\00\104\00\0004\00\00P4\00\00p1\00\00\901\00\00 -\00\00@-\00\00p4\00\00\904\00\00\b04\00\00`-\00\00\d04\00\00\f04\00\00\105\00\00\f01\00\00\102\00\0002\00\00P2\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\a0\'\00\00\c0\'\00\00 0\00\00 0\00\00 0\00\00 0\00\00@(\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\80-\00\00\a0-\00\00\c0-\00\00\e0-\00\00\00.\00\00 .\00\00@.\00\0005\00\00P5\00\00p5\00\00`.\00\00\80.\00\00\a0.\00\00\c0.\00\00\e0.\00\00\00/\00\00 /\00\00\905\00\00\b05\00\00\d05\00\00\00,\00\00 ,\00\00@,\00\00@/\00\00`/\00\00\80/\00\00p3\00\00\903\00\00\b01\00\00\d01\00\00p2\00\00\902\00\00\b02\00\00\d02\00\00`,\00\00\80,\00\00\a0,\00\00\a0/\00\00\c0/\00\00\e0/\00\00\000") (data $319 (i32.const 15244) ",") (data $319.1 (i32.const 15256) "\1a\00\00\00\10\00\00\00\f07\00\00\f07\00\00\9c\03\00\00\e7") (data $320 (i32.const 15292) "\1c") @@ -691,178 +695,197 @@ (data $321.1 (i32.const 15336) "\1b\00\00\00\10\00\00\00\d0;\00\00\d0;\00\00\08\00\00\00\08") (data $322 (i32.const 15372) "\1c") (data $322.1 (i32.const 15384) "\1c\00\00\00\08\00\00\00\9a") - (data $323 (i32.const 15404) "\1c") - (data $323.1 (i32.const 15416) "\02") - (data $324 (i32.const 15436) "L") - (data $324.1 (i32.const 15448) "\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 ") - (data $325 (i32.const 15516) ",") - (data $325.1 (i32.const 15528) "\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 ") - (data $326 (i32.const 15564) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00`<\00\00\00\00\00\00\b0<") - (data $327 (i32.const 15612) "|") - (data $327.1 (i32.const 15624) "\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006") - (data $328 (i32.const 15740) "<") - (data $328.1 (i32.const 15752) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s") - (data $329 (i32.const 15804) "\1c") - (data $329.1 (i32.const 15816) "\02\00\00\00\02\00\00\000") - (data $330 (i32.const 15836) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009") - (data $331 (i32.const 16236) "\1c\04") - (data $331.1 (i32.const 16248) "\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f") - (data $332 (i32.const 17292) "\\") - (data $332.1 (i32.const 17304) "\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z") - (data $333 (i32.const 17388) "<") - (data $333.1 (i32.const 17400) "\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s") - (data $334 (i32.const 17452) "l") - (data $334.1 (i32.const 17464) "\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 ") - (data $335 (i32.const 17564) ",") - (data $335.1 (i32.const 17576) "\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 ") - (data $336 (i32.const 17612) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00@D\00\00\00\00\00\00\b0D") - (data $337 (i32.const 17660) ",") - (data $337.1 (i32.const 17672) "\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n") - (data $338 (i32.const 17708) "\1c") - (data $338.1 (i32.const 17720) "\02\00\00\00\04\00\00\000\00x") - (data $339 (i32.const 17740) "\1c") - (data $339.1 (i32.const 17752) ")\00\00\00\08\00\00\00\9b") - (data $340 (i32.const 17772) "\1c") - (data $340.1 (i32.const 17784) "\02\00\00\00\04\00\00\00\n\00\n") - (data $341 (i32.const 17804) "|") - (data $341.1 (i32.const 17816) "\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y") - (data $342 (i32.const 17932) "L") - (data $342.1 (i32.const 17944) "\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>") - (data $343 (i32.const 18012) "l") - (data $343.1 (i32.const 18024) "\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!") - (data $344 (i32.const 18124) "L") - (data $344.1 (i32.const 18136) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00g\00e\00n\00e\00r\00i\00c\00.\00t\00s") - (data $345 (i32.const 18204) "\1c") - (data $345.1 (i32.const 18216) "\02\00\00\00\02\00\00\00\n") - (data $346 (i32.const 18236) "\1c") - (data $346.1 (i32.const 18248) "\02\00\00\00\04\00\00\00:\00 ") - (data $347 (i32.const 18268) "\1c") - (data $347.1 (i32.const 18280) "\02\00\00\00\02\00\00\00(") - (data $348 (i32.const 18300) "\1c") - (data $348.1 (i32.const 18312) "\02\00\00\00\02\00\00\00)") - (data $349 (i32.const 18332) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pG\00\00\00\00\00\00\90G") - (data $350 (i32.const 18364) "\1c") - (data $350.1 (i32.const 18376) "\02\00\00\00\02\00\00\00 ") - (data $351 (i32.const 18396) "\1c") - (data $351.1 (i32.const 18408) "\02\00\00\00\04\00\00\00,\00 ") - (data $352 (i32.const 18428) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00\d0G\00\00\00\00\00\00\f0G") - (data $353 (i32.const 18460) "|") - (data $353.1 (i32.const 18472) "\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 ") - (data $354 (i32.const 18588) ",") - (data $354.1 (i32.const 18600) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 ") - (data $355 (i32.const 18636) "\1c") - (data $355.1 (i32.const 18648) "\01") - (data $356 (i32.const 18668) "\1c") - (data $356.1 (i32.const 18680) "\01") - (data $357 (i32.const 18700) "\1c") - (data $357.1 (i32.const 18712) "\01") - (data $358 (i32.const 18732) "\1c") - (data $358.1 (i32.const 18744) "\01") - (data $359 (i32.const 18764) "\\") - (data $359.1 (i32.const 18776) "\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 ") - (data $360 (i32.const 18860) "<") - (data $360.1 (i32.const 18872) "\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s") - (data $361 (i32.const 18924) "l") - (data $361.1 (i32.const 18936) "\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!") - (data $362 (i32.const 19036) ",") - (data $362.1 (i32.const 19048) "\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 ") - (data $363 (i32.const 19084) ",") - (data $363.1 (i32.const 19096) "\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)") - (data $364 (i32.const 19132) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pJ\00\00\00\00\00\00\a0J") - (data $365 (i32.const 19164) "\1c\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\0c\00\00\00pJ\00\00\00\00\00\00\a0J") - (data $366 (i32.const 19196) "\1c") - (data $366.1 (i32.const 19208) "5\00\00\00\08\00\00\00\9c") - (data $367 (i32.const 19228) "<") - (data $367.1 (i32.const 19240) "\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 ") - (data $368 (i32.const 19292) "\1c") - (data $368.1 (i32.const 19304) "\02\00\00\00\n\00\00\00P\00C\00 \00=\00 ") - (data $369 (i32.const 19324) ",") - (data $369.1 (i32.const 19336) "\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 ") - (data $370 (i32.const 19372) "\1c") - (data $370.1 (i32.const 19384) "5\00\00\00\08\00\00\00\9d") - (data $371 (i32.const 19404) ",") - (data $371.1 (i32.const 19416) "\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 ") - (data $372 (i32.const 19452) "\1c") - (data $372.1 (i32.const 19464) "\02\00\00\00\04\00\00\00 \00(") - (data $373 (i32.const 19484) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\14\00\00\00\e0K\00\00\00\00\00\00\10L\00\00\00\00\00\00\90G") - (data $374 (i32.const 19532) "L") - (data $374.1 (i32.const 19544) "\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 ") - (data $375 (i32.const 19612) "<") - (data $375.1 (i32.const 19624) "\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s") - (data $376 (i32.const 19676) ",") - (data $376.1 (i32.const 19688) "\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 ") - (data $377 (i32.const 19724) "\1c") - (data $377.1 (i32.const 19736) "\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x") - (data $378 (i32.const 19756) "\1c") - (data $378.1 (i32.const 19768) "\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 ") - (data $379 (i32.const 19788) "\1c") - (data $379.1 (i32.const 19800) "\02\00\00\00\08\00\00\00,\00\n\00 \00 ") - (data $380 (i32.const 19820) "|\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00`\00\00\00\f0L\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00@M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00`M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M\00\00\00\00\00\00`M\00\00\00\00\00\00\10L\00\00\00\00\00\00 M") - (data $381 (i32.const 19948) ",") - (data $381.1 (i32.const 19960) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t") - (data $382 (i32.const 19996) "L") - (data $382.1 (i32.const 20008) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s") - (data $383 (i32.const 20076) "\1c") - (data $383.1 (i32.const 20088) "\01") - (data $384 (i32.const 20108) "\1c") - (data $384.1 (i32.const 20120) "\01") - (data $385 (i32.const 20140) "\1c") - (data $385.1 (i32.const 20152) "\01") - (data $386 (i32.const 20172) "\1c") - (data $386.1 (i32.const 20184) "\01") - (data $387 (i32.const 20204) "L") - (data $387.1 (i32.const 20216) "\02\00\00\00:\00\00\00S\00P\00I\00 \00r\00u\00n\00n\00i\00n\00g\00 \00n\00o\00t\00 \00s\00u\00p\00p\00o\00r\00t\00e\00d\00 \00y\00e\00t") - (data $388 (i32.const 20284) "<") - (data $388.1 (i32.const 20296) "\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00d\00e\00x\00.\00t\00s") - (data $389 (i32.const 20348) "L") - (data $389.1 (i32.const 20360) "\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s") - (data $390 (i32.const 20428) "\1c") - (data $390.1 (i32.const 20440) "\01") - (data $391 (i32.const 20460) "<") - (data $391.1 (i32.const 20472) "\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s") - (data $392 (i32.const 20524) "L") - (data $392.1 (i32.const 20536) "\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 ") - (data $393 (i32.const 20604) "\\") - (data $393.1 (i32.const 20616) "\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 ") - (data $394 (i32.const 20700) ",") - (data $394.1 (i32.const 20712) "\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 ") - (data $395 (i32.const 20748) ",\00\00\00\03\00\00\00\00\00\00\00\'\00\00\00\10\00\00\00\90P\00\00\00\00\00\00\f0P") - (data $396 (i32.const 20796) "<") - (data $396.1 (i32.const 20808) "\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00.\00t\00s") - (data $397 (i32.const 20860) "\1c") - (data $397.1 (i32.const 20872) "\01") - (data $398 (i32.const 20892) "\1c") - (data $398.1 (i32.const 20904) "\01") - (data $399 (i32.const 20924) "<") - (data $399.1 (i32.const 20936) "\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d") - (data $400 (i32.const 20988) "<") - (data $400.1 (i32.const 21000) "\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d") - (data $401 (i32.const 21056) "<\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 ") - (data $401.1 (i32.const 21116) "$\02") - (data $401.2 (i32.const 21128) "\02A\00\00\10A\02\00 ") - (data $401.3 (i32.const 21152) "d") - (data $401.4 (i32.const 21164) "\02A\00\00B") - (data $401.5 (i32.const 21188) "$\01") - (data $401.6 (i32.const 21200) "$\t\00\00 ") - (data $401.7 (i32.const 21216) "\04A\00\00 \00\00\00\00\00\00\00\02\01\00\00\02\02") - (data $401.8 (i32.const 21244) "\02A\00\00\00\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02A") - (data $401.9 (i32.const 21280) " \00\00\00 \00\00\00\02A\00\00d") + (data $323 (i32.const 15404) "L") + (data $323.1 (i32.const 15416) "\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>") + (data $324 (i32.const 15484) "\1c") + (data $324.1 (i32.const 15496) "\02") + (data $325 (i32.const 15516) "l") + (data $325.1 (i32.const 15528) "\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!") + (data $326 (i32.const 15628) "L") + (data $326.1 (i32.const 15640) "\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00i\00n\00t\00e\00r\00n\00a\00l\00.\00t\00s") + (data $327 (i32.const 15708) "|") + (data $327.1 (i32.const 15720) "\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y") + (data $328 (i32.const 15836) "\1c") + (data $328.1 (i32.const 15848) "\02\00\00\00\02\00\00\00\n") + (data $329 (i32.const 15868) "|") + (data $329.1 (i32.const 15880) "\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006") + (data $330 (i32.const 15996) "<") + (data $330.1 (i32.const 16008) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s") + (data $331 (i32.const 16060) "\1c") + (data $331.1 (i32.const 16072) "\02\00\00\00\02\00\00\000") + (data $332 (i32.const 16092) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009") + (data $333 (i32.const 16492) "\1c\04") + (data $333.1 (i32.const 16504) "\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f") + (data $334 (i32.const 17548) "\\") + (data $334.1 (i32.const 17560) "\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z") + (data $335 (i32.const 17644) "\1c") + (data $335.1 (i32.const 17656) "\02\00\00\00\04\00\00\00:\00 ") + (data $336 (i32.const 17676) "\1c") + (data $336.1 (i32.const 17688) "\02\00\00\00\02\00\00\00(") + (data $337 (i32.const 17708) "\1c") + (data $337.1 (i32.const 17720) "\02\00\00\00\02\00\00\00)") + (data $338 (i32.const 17740) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00 E\00\00\00\00\00\00@E") + (data $339 (i32.const 17772) "\1c") + (data $339.1 (i32.const 17784) "\02\00\00\00\02\00\00\00 ") + (data $340 (i32.const 17804) "\1c") + (data $340.1 (i32.const 17816) "\02\00\00\00\04\00\00\00,\00 ") + (data $341 (i32.const 17836) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\80E\00\00\00\00\00\00\a0E") + (data $342 (i32.const 17868) "L") + (data $342.1 (i32.const 17880) "\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 ") + (data $343 (i32.const 17948) "L") + (data $343.1 (i32.const 17960) "\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s") + (data $344 (i32.const 18028) "\1c") + (data $344.1 (i32.const 18040) "\01") + (data $345 (i32.const 18060) "<") + (data $345.1 (i32.const 18072) "\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s") + (data $346 (i32.const 18124) "L") + (data $346.1 (i32.const 18136) "\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 ") + (data $347 (i32.const 18204) "<") + (data $347.1 (i32.const 18216) "\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s") + (data $348 (i32.const 18268) "L") + (data $348.1 (i32.const 18280) "\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 ") + (data $349 (i32.const 18348) ",") + (data $349.1 (i32.const 18360) "\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 ") + (data $350 (i32.const 18396) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00pG\00\00\00\00\00\00\c0G") + (data $351 (i32.const 18444) "l") + (data $351.1 (i32.const 18456) "\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 ") + (data $352 (i32.const 18556) ",") + (data $352.1 (i32.const 18568) "\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 ") + (data $353 (i32.const 18604) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00 H\00\00\00\00\00\00\90H") + (data $354 (i32.const 18652) "\\") + (data $354.1 (i32.const 18664) "\02\00\00\00D\00\00\00A\00r\00g\00u\00m\00e\00n\00t\00s\00 \00l\00e\00n\00g\00t\00h\00 \00i\00s\00 \00t\00o\00o\00 \00b\00i\00g\00.\00 \00G\00o\00t\00:\00 ") + (data $355 (i32.const 18748) ",") + (data $355.1 (i32.const 18760) "\02\00\00\00\0e\00\00\00,\00 \00m\00a\00x\00:\00 ") + (data $356 (i32.const 18796) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00\f0H\00\00\00\00\00\00PI") + (data $357 (i32.const 18844) "<") + (data $357.1 (i32.const 18856) "\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00s\00p\00i\00.\00t\00s") + (data $358 (i32.const 18908) "|") + (data $358.1 (i32.const 18920) "\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 ") + (data $359 (i32.const 19036) "\1c") + (data $359.1 (i32.const 19048) "\01") + (data $360 (i32.const 19068) "\\") + (data $360.1 (i32.const 19080) "\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 ") + (data $361 (i32.const 19164) "<") + (data $361.1 (i32.const 19176) "\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s") + (data $362 (i32.const 19228) "l") + (data $362.1 (i32.const 19240) "\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!") + (data $363 (i32.const 19340) "L") + (data $363.1 (i32.const 19352) "\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00d\00e\00b\00u\00g\00g\00e\00r\00.\00t\00s") + (data $364 (i32.const 19420) "\\") + (data $364.1 (i32.const 19432) "\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 ") + (data $365 (i32.const 19516) ",") + (data $365.1 (i32.const 19528) "\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 ") + (data $366 (i32.const 19564) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00\f0K\00\00\00\00\00\00PL") + (data $367 (i32.const 19612) "\1c") + (data $367.1 (i32.const 19624) "\01") + (data $368 (i32.const 19644) "\1c") + (data $368.1 (i32.const 19656) "\01") + (data $369 (i32.const 19676) "\1c") + (data $369.1 (i32.const 19688) "\01") + (data $370 (i32.const 19708) ",") + (data $370.1 (i32.const 19720) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t") + (data $371 (i32.const 19756) "L") + (data $371.1 (i32.const 19768) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s") + (data $372 (i32.const 19836) "\1c") + (data $372.1 (i32.const 19848) "\01") + (data $373 (i32.const 19868) "\1c") + (data $373.1 (i32.const 19880) "\01") + (data $374 (i32.const 19900) "\1c") + (data $374.1 (i32.const 19912) "\01") + (data $375 (i32.const 19932) "\1c") + (data $375.1 (i32.const 19944) "\01") + (data $376 (i32.const 19964) ",") + (data $376.1 (i32.const 19976) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 ") + (data $377 (i32.const 20012) "<") + (data $377.1 (i32.const 20024) "\02\00\00\00*\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00u\00t\00i\00l\00s\00.\00t\00s") + (data $378 (i32.const 20076) "<") + (data $378.1 (i32.const 20088) "\02\00\00\00*\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00g\00a\00s\00-\00c\00o\00s\00t\00s\00.\00t\00s") + (data $379 (i32.const 20140) "\1c") + (data $379.1 (i32.const 20152) "\01") + (data $380 (i32.const 20172) "\1c") + (data $380.1 (i32.const 20184) "\01") + (data $381 (i32.const 20204) "\1c") + (data $381.1 (i32.const 20216) "\01") + (data $382 (i32.const 20236) "\1c") + (data $382.1 (i32.const 20248) "\01") + (data $383 (i32.const 20268) ",") + (data $383.1 (i32.const 20280) "\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n") + (data $384 (i32.const 20316) "\1c") + (data $384.1 (i32.const 20328) "\02\00\00\00\04\00\00\000\00x") + (data $385 (i32.const 20348) "\1c") + (data $385.1 (i32.const 20360) ":\00\00\00\08\00\00\00\9b") + (data $386 (i32.const 20380) "\1c") + (data $386.1 (i32.const 20392) "\02\00\00\00\04\00\00\00\n\00\n") + (data $387 (i32.const 20412) ",") + (data $387.1 (i32.const 20424) "\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 ") + (data $388 (i32.const 20460) ",") + (data $388.1 (i32.const 20472) "\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)") + (data $389 (i32.const 20508) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\d0O\00\00\00\00\00\00\00P") + (data $390 (i32.const 20540) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\d0O\00\00\00\00\00\00\00P") + (data $391 (i32.const 20572) "\1c") + (data $391.1 (i32.const 20584) ">\00\00\00\08\00\00\00\9c") + (data $392 (i32.const 20604) "<") + (data $392.1 (i32.const 20616) "\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 ") + (data $393 (i32.const 20668) "\1c") + (data $393.1 (i32.const 20680) "\02\00\00\00\n\00\00\00P\00C\00 \00=\00 ") + (data $394 (i32.const 20700) "\1c") + (data $394.1 (i32.const 20712) "\02\00\00\00\0c\00\00\00G\00A\00S\00 \00=\00 ") + (data $395 (i32.const 20732) ",") + (data $395.1 (i32.const 20744) "\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 ") + (data $396 (i32.const 20780) "\1c") + (data $396.1 (i32.const 20792) ">\00\00\00\08\00\00\00\9d") + (data $397 (i32.const 20812) ",") + (data $397.1 (i32.const 20824) "\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 ") + (data $398 (i32.const 20860) "\1c") + (data $398.1 (i32.const 20872) "\02\00\00\00\04\00\00\00 \00(") + (data $399 (i32.const 20892) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\14\00\00\00`Q\00\00\00\00\00\00\90Q\00\00\00\00\00\00@E") + (data $400 (i32.const 20940) "<") + (data $400.1 (i32.const 20952) "\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s") + (data $401 (i32.const 21004) ",") + (data $401.1 (i32.const 21016) "\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 ") + (data $402 (i32.const 21052) "\1c") + (data $402.1 (i32.const 21064) "\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x") + (data $403 (i32.const 21084) "\1c") + (data $403.1 (i32.const 21096) "\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 ") + (data $404 (i32.const 21116) "\1c") + (data $404.1 (i32.const 21128) "\02\00\00\00\08\00\00\00,\00\n\00 \00 ") + (data $405 (i32.const 21148) "|\00\00\00\03\00\00\00\00\00\00\00%\00\00\00`\00\00\00 R\00\00\00\00\00\00\90Q\00\00\00\00\00\00PR\00\00\00\00\00\00pR\00\00\00\00\00\00\90Q\00\00\00\00\00\00PR\00\00\00\00\00\00\90R\00\00\00\00\00\00\90Q\00\00\00\00\00\00PR\00\00\00\00\00\00\90R\00\00\00\00\00\00\90Q\00\00\00\00\00\00PR") + (data $406 (i32.const 21276) "\1c") + (data $406.1 (i32.const 21288) "\01") + (data $407 (i32.const 21308) "\1c") + (data $407.1 (i32.const 21320) "\01") + (data $408 (i32.const 21340) "\1c") + (data $408.1 (i32.const 21352) "\01") + (data $409 (i32.const 21372) "<") + (data $409.1 (i32.const 21384) "\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d") + (data $410 (i32.const 21436) "<") + (data $410.1 (i32.const 21448) "\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d") + (data $411 (i32.const 21504) "@\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 ") + (data $411.1 (i32.const 21564) "$\02") + (data $411.2 (i32.const 21576) "\02A\00\00\10A\02\00 ") + (data $411.3 (i32.const 21600) "d") + (data $411.4 (i32.const 21612) "\02A\00\00B") + (data $411.5 (i32.const 21636) "$\01") + (data $411.6 (i32.const 21648) "$\t\00\00 \00\00\00\04A\00\00\02\01\00\00d") + (data $411.7 (i32.const 21680) " ") + (data $411.8 (i32.const 21692) " \00\00\00\02A\00\00 \00\00\00\02A\00\00\00\00\00\00\02A\00\00 \00\00\00 \00\00\00 \00\00\00\02A\00\00\02\02\00\00\10A\02") + (data $411.9 (i32.const 21752) "\02A") (table $0 158 158 funcref) - (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $assembly/index/disassemble~anonymous|0 $assembly/api-generic/runVm~anonymous|0 $assembly/api-generic/runVm~anonymous|0) - (export "InputKind.Generic" (global $assembly/index/InputKind.Generic)) - (export "InputKind.SPI" (global $assembly/index/InputKind.SPI)) - (export "HasMetadata.Yes" (global $assembly/index/HasMetadata.Yes)) - (export "HasMetadata.No" (global $assembly/index/HasMetadata.No)) - (export "nextStep" (func $assembly/api/nextStep)) - (export "nSteps" (func $assembly/api/nSteps)) - (export "getProgramCounter" (func $assembly/api/getProgramCounter)) - (export "setNextProgramCounter" (func $assembly/api/setNextProgramCounter)) - (export "getStatus" (func $assembly/api/getStatus)) - (export "getExitArg" (func $assembly/api/getExitArg)) - (export "getGasLeft" (func $assembly/api/getGasLeft)) - (export "setGasLeft" (func $assembly/api/setGasLeft)) - (export "getRegisters" (func $assembly/api/getRegisters)) - (export "getPageDump" (func $assembly/api/getPageDump)) + (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/codec~anonymous|0 $assembly/api-utils/disassemble~anonymous|0 $assembly/api-internal/executeProgram~anonymous|0 $assembly/api-internal/executeProgram~anonymous|0) + (export "nextStep" (func $assembly/api-debugger/nextStep)) + (export "nSteps" (func $assembly/api-debugger/nSteps)) + (export "getProgramCounter" (func $assembly/api-debugger/getProgramCounter)) + (export "setNextProgramCounter" (func $assembly/api-debugger/setNextProgramCounter)) + (export "getStatus" (func $assembly/api-debugger/getStatus)) + (export "getExitArg" (func $assembly/api-debugger/getExitArg)) + (export "getGasLeft" (func $assembly/api-debugger/getGasLeft)) + (export "setGasLeft" (func $assembly/api-debugger/setGasLeft)) + (export "getRegisters" (func $assembly/api-debugger/getRegisters)) + (export "getPageDump" (func $assembly/api-debugger/getPageDump)) + (export "InputKind.Generic" (global $assembly/api-utils/InputKind.Generic)) + (export "InputKind.SPI" (global $assembly/api-utils/InputKind.SPI)) + (export "HasMetadata.Yes" (global $assembly/api-utils/HasMetadata.Yes)) + (export "HasMetadata.No" (global $assembly/api-utils/HasMetadata.No)) (export "__new" (func $~lib/rt/itcms/__new)) (export "__pin" (func $~lib/rt/itcms/__pin)) (export "__unpin" (func $~lib/rt/itcms/__unpin)) @@ -870,15 +893,17 @@ (export "__rtti_base" (global $~lib/rt/__rtti_base)) (export "memory" (memory $0)) (export "__setArgumentsLength" (func $~setArgumentsLength)) - (export "disassemble" (func $export:assembly/index/disassemble)) - (export "runProgram" (func $export:assembly/index/runProgram)) - (export "runVm" (func $export:assembly/api-generic/runVm@varargs)) - (export "getAssembly" (func $export:assembly/api-generic/getAssembly)) + (export "getAssembly" (func $export:assembly/api-internal/getAssembly)) (export "wrapAsProgram" (func $export:assembly/program-build/wrapAsProgram)) - (export "resetGeneric" (func $export:assembly/api/resetGeneric)) - (export "resetGenericWithMemory" (func $export:assembly/api/resetGenericWithMemory)) - (export "setRegisters" (func $export:assembly/api/setRegisters)) - (export "setMemory" (func $export:assembly/api/setMemory)) + (export "resetJAM" (func $export:assembly/api-debugger/resetJAM@varargs)) + (export "resetGeneric" (func $export:assembly/api-debugger/resetGeneric@varargs)) + (export "resetGenericWithMemory" (func $export:assembly/api-debugger/resetGenericWithMemory@varargs)) + (export "setRegisters" (func $export:assembly/api-debugger/setRegisters)) + (export "setMemory" (func $export:assembly/api-debugger/setMemory)) + (export "getGasCosts" (func $export:assembly/api-utils/getGasCosts)) + (export "disassemble" (func $export:assembly/api-utils/disassemble)) + (export "prepareProgram" (func $export:assembly/api-utils/prepareProgram)) + (export "runProgram" (func $export:assembly/api-utils/runProgram@varargs)) (start $~start) (func $~lib/rt/itcms/visitRoots (local $0 i32) @@ -887,60 +912,60 @@ call $~lib/rt/itcms/__visit i32.const 9200 call $~lib/rt/itcms/__visit - i32.const 14144 + i32.const 12448 call $~lib/rt/itcms/__visit - i32.const 17824 + i32.const 15728 call $~lib/rt/itcms/__visit i32.const 10400 call $~lib/rt/itcms/__visit i32.const 1312 call $~lib/rt/itcms/__visit - i32.const 20944 + i32.const 21392 call $~lib/rt/itcms/__visit - i32.const 21008 + i32.const 21456 call $~lib/rt/itcms/__visit - i32.const 16256 + i32.const 16512 call $~lib/rt/itcms/__visit - i32.const 17312 + i32.const 17568 call $~lib/rt/itcms/__visit - global.get $assembly/api/interpreter + global.get $assembly/api-debugger/interpreter local.tee $0 if local.get $0 call $~lib/rt/itcms/__visit end - i32.const 1136 - call $~lib/rt/itcms/__visit - i32.const 1264 - call $~lib/rt/itcms/__visit - i32.const 2272 + i32.const 15344 call $~lib/rt/itcms/__visit - global.get $assembly/instructions/INSTRUCTIONS + global.get $assembly/memory/NO_PAGE_FAULT local.tee $0 if local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/memory/NO_PAGE_FAULT + global.get $assembly/memory/EMPTY_UINT8ARRAY local.tee $0 if local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/memory/EMPTY_UINT8ARRAY + global.get $assembly/memory/EMPTY_PAGE local.tee $0 if local.get $0 call $~lib/rt/itcms/__visit end - global.get $assembly/memory/EMPTY_PAGE + i32.const 1136 + call $~lib/rt/itcms/__visit + i32.const 1264 + call $~lib/rt/itcms/__visit + i32.const 2272 + call $~lib/rt/itcms/__visit + global.get $assembly/instructions/INSTRUCTIONS local.tee $0 if local.get $0 call $~lib/rt/itcms/__visit end - i32.const 15344 - call $~lib/rt/itcms/__visit i32.const 15264 call $~lib/rt/itcms/__visit global.get $~lib/rt/itcms/pinSpace @@ -994,7 +1019,7 @@ i32.load offset=8 i32.eqz local.get $0 - i32.const 54068 + i32.const 54532 i32.lt_u i32.and i32.eqz @@ -1068,7 +1093,7 @@ i32.const 1 else local.get $2 - i32.const 21056 + i32.const 21504 i32.load i32.gt_u if @@ -1082,7 +1107,7 @@ local.get $2 i32.const 2 i32.shl - i32.const 21060 + i32.const 21508 i32.add i32.load i32.const 32 @@ -1666,10 +1691,10 @@ if unreachable end - i32.const 54080 + i32.const 54544 i32.const 0 i32.store - i32.const 55648 + i32.const 56112 i32.const 0 i32.store loop $for-loop|0 @@ -1680,7 +1705,7 @@ local.get $0 i32.const 2 i32.shl - i32.const 54080 + i32.const 54544 i32.add i32.const 0 i32.store offset=4 @@ -1698,7 +1723,7 @@ i32.add i32.const 2 i32.shl - i32.const 54080 + i32.const 54544 i32.add i32.const 0 i32.store offset=96 @@ -1716,14 +1741,14 @@ br $for-loop|0 end end - i32.const 54080 - i32.const 55652 + i32.const 54544 + i32.const 56116 memory.size i64.extend_i32_s i64.const 16 i64.shl call $~lib/rt/tlsf/addMemory - i32.const 54080 + i32.const 54544 global.set $~lib/rt/tlsf/ROOT ) (func $~lib/rt/itcms/step (result i32) @@ -1808,7 +1833,7 @@ local.set $0 loop $while-continue|0 local.get $0 - i32.const 54068 + i32.const 54532 i32.lt_u if local.get $0 @@ -1904,7 +1929,7 @@ unreachable end local.get $0 - i32.const 54068 + i32.const 54532 i32.lt_u if local.get $0 @@ -1927,7 +1952,7 @@ i32.const 4 i32.add local.tee $0 - i32.const 54068 + i32.const 54532 i32.ge_u if global.get $~lib/rt/tlsf/ROOT @@ -2544,11 +2569,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -2610,7 +2635,7 @@ i32.div_u i32.const 2 i32.shl - i32.const 15836 + i32.const 16092 i32.add i64.load32_u local.get $3 @@ -2618,7 +2643,7 @@ i32.rem_u i32.const 2 i32.shl - i32.const 15836 + i32.const 16092 i32.add i64.load32_u i64.const 32 @@ -2645,7 +2670,7 @@ i32.rem_u i32.const 2 i32.shl - i32.const 15836 + i32.const 16092 i32.add i32.load i32.store @@ -2668,7 +2693,7 @@ local.get $1 i32.const 2 i32.shl - i32.const 15836 + i32.const 16092 i32.add i32.load i32.store @@ -2718,7 +2743,7 @@ i32.wrap_i64 i32.const 1 i32.shl - i32.const 17312 + i32.const 17568 i32.add i32.load16_u i32.store16 @@ -2753,7 +2778,7 @@ i32.wrap_i64 i32.const 1 i32.shl - i32.const 17312 + i32.const 17568 i32.add i32.load16_u i32.store16 @@ -2776,11 +2801,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -2789,7 +2814,7 @@ global.get $~lib/memory/__stack_pointer i32.const 0 i32.store - block $__inlined_func$~lib/util/number/itoa32$98 + block $__inlined_func$~lib/util/number/itoa32$100 local.get $0 i32.eqz if @@ -2797,9 +2822,9 @@ i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - i32.const 15824 + i32.const 16080 local.set $0 - br $__inlined_func$~lib/util/number/itoa32$98 + br $__inlined_func$~lib/util/number/itoa32$100 end global.get $~lib/memory/__stack_pointer i32.const 0 @@ -2920,7 +2945,7 @@ i32.div_u i32.const 2 i32.shl - i32.const 15836 + i32.const 16092 i32.add i64.load32_u local.get $4 @@ -2928,7 +2953,7 @@ i32.rem_u i32.const 2 i32.shl - i32.const 15836 + i32.const 16092 i32.add i64.load32_u i64.const 32 @@ -2951,7 +2976,7 @@ i32.div_u i32.const 2 i32.shl - i32.const 15836 + i32.const 16092 i32.add i64.load32_u local.get $3 @@ -2959,7 +2984,7 @@ i32.rem_u i32.const 2 i32.shl - i32.const 15836 + i32.const 16092 i32.add i64.load32_u i64.const 32 @@ -3123,7 +3148,7 @@ i32.const 3 i32.eq if - i32.const 20944 + i32.const 21392 i32.const 1376 i32.const 338 i32.const 7 @@ -3176,7 +3201,7 @@ i32.const 3 i32.ne if - i32.const 21008 + i32.const 21456 i32.const 1376 i32.const 352 i32.const 5 @@ -3257,7 +3282,7 @@ i32.const 8 i32.sub i32.load - i32.const 51 + i32.const 46 i32.eq if global.get $~lib/memory/__stack_pointer @@ -3265,11 +3290,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3297,50 +3322,67 @@ i32.const 8 i32.sub i32.load - i32.const 51 + i32.const 46 i32.eq if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + block $__inlined_func$assembly/gas/GasCounterU64#sub$106 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i64.load + local.get $1 + i64.sub + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load + i64.const 0 + i64.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 1 + br $__inlined_func$assembly/gas/GasCounterU64#sub$106 + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i64.load - local.get $1 - i64.sub - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load - i64.const 0 - i64.lt_s - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer return end unreachable @@ -3351,7 +3393,7 @@ i32.const 8 i32.sub i32.load - i32.const 51 + i32.const 46 i32.eq if global.get $~lib/memory/__stack_pointer @@ -3359,11 +3401,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3385,6 +3427,79 @@ end unreachable ) + (func $"~lib/map/Map~visit" (param $0 i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + local.tee $2 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=16 + i32.const 12 + i32.mul + i32.add + local.set $0 + loop $while-continue|0 + local.get $0 + local.get $1 + i32.gt_u + if + local.get $1 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if + local.get $1 + i32.load offset=4 + call $~lib/rt/itcms/__visit + end + local.get $1 + i32.const 12 + i32.add + local.set $1 + br $while-continue|0 + end + end + local.get $2 + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) (func $assembly/interpreter/Interpreter~visit (param $0 i32) local.get $0 i32.load @@ -3414,38 +3529,44 @@ block $folding-inner1 block $folding-inner0 block $invalid - block $~lib/staticarray/StaticArray - block $assembly/interpreter/BranchResult - block $assembly/interpreter/DjumpResult - block $assembly/program/ResolvedArguments - block $assembly/gas/GasCounterU64 - block $assembly/api-generic/InitialPage - block $assembly/api-generic/VmInput - block $assembly/api-generic/VmOutput - block $assembly/codec/ValOffset - block $~lib/staticarray/StaticArray<~lib/string/String> - block $assembly/gas/GasCounter - block $~lib/staticarray/StaticArray - block $~lib/staticarray/StaticArray - block $assembly/program/Program - block $assembly/interpreter/Interpreter - block $assembly/memory/Chunks - block $~lib/staticarray/StaticArray - block $assembly/memory/Result - block $assembly/instructions/outcome/OutcomeData - block $"~lib/map/Map" - block $~lib/staticarray/StaticArray - block $assembly/memory/MaybePageFault - block $assembly/arguments/Nibbles - block $assembly/arguments/Args - block $~lib/string/String - block $~lib/arraybuffer/ArrayBuffer - block $~lib/object/Object - local.get $0 - i32.const 8 - i32.sub - i32.load - br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $folding-inner0 $folding-inner1 $folding-inner0 $assembly/arguments/Args $folding-inner2 $folding-inner3 $assembly/arguments/Nibbles $folding-inner1 $assembly/memory/MaybePageFault $folding-inner4 $folding-inner4 $~lib/staticarray/StaticArray $folding-inner5 $folding-inner0 $folding-inner2 $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $folding-inner3 $assembly/memory/Result $folding-inner6 $~lib/staticarray/StaticArray $assembly/memory/Chunks $folding-inner6 $folding-inner2 $folding-inner1 $folding-inner3 $assembly/interpreter/Interpreter $assembly/program/Program $folding-inner0 $~lib/staticarray/StaticArray $folding-inner0 $folding-inner0 $~lib/staticarray/StaticArray $assembly/gas/GasCounter $folding-inner6 $folding-inner0 $~lib/staticarray/StaticArray<~lib/string/String> $assembly/codec/ValOffset $folding-inner3 $folding-inner1 $folding-inner1 $assembly/api-generic/VmOutput $folding-inner4 $folding-inner2 $assembly/api-generic/VmInput $assembly/api-generic/InitialPage $folding-inner2 $folding-inner6 $assembly/gas/GasCounterU64 $folding-inner2 $folding-inner3 $assembly/program/ResolvedArguments $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $folding-inner2 $~lib/staticarray/StaticArray $folding-inner0 $invalid + block $assembly/program/ResolvedArguments + block $assembly/api-internal/VmOutput + block $"~lib/map/Map" + block $assembly/gas-costs/BlockGasCost + block $assembly/interpreter/BranchResult + block $assembly/interpreter/DjumpResult + block $assembly/api-internal/InitialPage + block $assembly/gas/GasCounterU64 + block $assembly/spi/StandardProgram + block $assembly/codec/ValOffset + block $~lib/staticarray/StaticArray + block $~lib/staticarray/StaticArray<~lib/string/String> + block $assembly/gas/GasCounter + block $~lib/staticarray/StaticArray + block $~lib/staticarray/StaticArray + block $assembly/program/Program + block $assembly/interpreter/Interpreter + block $assembly/memory/Chunks + block $~lib/staticarray/StaticArray + block $assembly/memory/Result + block $assembly/instructions/outcome/OutcomeData + block $"~lib/map/Map" + block $~lib/staticarray/StaticArray + block $assembly/memory/MaybePageFault + block $assembly/arguments/Nibbles + block $assembly/arguments/Args + block $~lib/string/String + block $~lib/arraybuffer/ArrayBuffer + block $~lib/object/Object + local.get $0 + i32.const 8 + i32.sub + i32.load + br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $folding-inner4 $folding-inner0 $folding-inner4 $assembly/arguments/Args $folding-inner1 $folding-inner2 $assembly/arguments/Nibbles $folding-inner0 $assembly/memory/MaybePageFault $folding-inner5 $folding-inner5 $~lib/staticarray/StaticArray $folding-inner6 $folding-inner4 $folding-inner1 $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $folding-inner2 $assembly/memory/Result $folding-inner3 $~lib/staticarray/StaticArray $assembly/memory/Chunks $folding-inner3 $folding-inner1 $folding-inner0 $folding-inner2 $assembly/interpreter/Interpreter $assembly/program/Program $folding-inner4 $~lib/staticarray/StaticArray $folding-inner4 $folding-inner4 $~lib/staticarray/StaticArray $assembly/gas/GasCounter $~lib/staticarray/StaticArray<~lib/string/String> $folding-inner0 $~lib/staticarray/StaticArray $folding-inner4 $folding-inner3 $folding-inner4 $assembly/codec/ValOffset $assembly/spi/StandardProgram $folding-inner3 $assembly/gas/GasCounterU64 $folding-inner1 $assembly/api-internal/InitialPage $folding-inner1 $folding-inner5 $folding-inner1 $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $assembly/gas-costs/BlockGasCost $folding-inner1 $folding-inner0 $"~lib/map/Map" $folding-inner2 $assembly/api-internal/VmOutput $folding-inner7 $folding-inner1 $folding-inner2 $assembly/program/ResolvedArguments $invalid + end + return + end + return end return end @@ -3457,193 +3578,173 @@ end return end + local.get $0 + call $"~lib/map/Map~visit" return end return end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner7 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store local.get $0 i32.load offset=8 - local.tee $2 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=16 - i32.const 12 - i32.mul - i32.add - local.set $0 - loop $while-continue|0 - local.get $0 - local.get $1 - i32.gt_u - if - local.get $1 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - local.get $1 - i32.load offset=4 - call $~lib/rt/itcms/__visit - end - local.get $1 - i32.const 12 - i32.add - local.set $1 - br $while-continue|0 - end - end - local.get $2 call $~lib/rt/itcms/__visit - br $folding-inner9 + return end return end local.get $0 - i32.load offset=8 + i32.load call $~lib/rt/itcms/__visit - return + br $folding-inner6 end + local.get $0 + call $assembly/interpreter/Interpreter~visit return end local.get $0 - i32.load - call $~lib/rt/itcms/__visit - br $folding-inner5 + call $assembly/interpreter/Interpreter~visit + return end - local.get $0 - call $assembly/interpreter/Interpreter~visit return end - local.get $0 - call $assembly/interpreter/Interpreter~visit return end return end - return - end - return - end - local.get $0 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.add - local.set $1 - loop $while-continue|01 - local.get $0 - local.get $1 - i32.lt_u - if local.get $0 - i32.load - local.tee $2 - if - local.get $2 - call $~lib/rt/itcms/__visit - end local.get $0 - i32.const 4 + i32.const 20 + i32.sub + i32.load offset=16 i32.add - local.set $0 - br $while-continue|01 + local.set $1 + loop $while-continue|0 + local.get $0 + local.get $1 + i32.lt_u + if + local.get $0 + i32.load + local.tee $2 + if + local.get $2 + call $~lib/rt/itcms/__visit + end + local.get $0 + i32.const 4 + i32.add + local.set $0 + br $while-continue|0 + end + end + return end + return end return end - return + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + br $folding-inner7 end - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - call $~lib/rt/itcms/__visit return end - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=16 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=20 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=24 - call $~lib/rt/itcms/__visit return end return end return end - local.get $0 - i32.load offset=32 - call $~lib/rt/itcms/__visit return end + local.get $0 + call $"~lib/map/Map~visit" return end + local.get $0 + i32.load offset=4 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=12 + call $~lib/rt/itcms/__visit return end + local.get $0 + i32.load offset=32 + call $~lib/rt/itcms/__visit return end unreachable end - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - return + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner8 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + br $folding-inner9 end global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner7 + br_if $folding-inner8 global.get $~lib/memory/__stack_pointer i32.const 0 i32.store - br $folding-inner8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.const 2 + i32.shl + i32.add + local.set $3 + loop $while-continue|00 + local.get $1 + local.get $3 + i32.lt_u + if + local.get $1 + i32.load + local.tee $2 + if + local.get $2 + call $~lib/rt/itcms/__visit + end + local.get $1 + i32.const 4 + i32.add + local.set $1 + br $while-continue|00 + end + end + br $folding-inner9 end global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner7 + br_if $folding-inner8 global.get $~lib/memory/__stack_pointer i32.const 0 i32.store @@ -3652,93 +3753,64 @@ i32.store local.get $0 i32.load offset=4 - local.set $1 + call $~lib/rt/itcms/__visit global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.const 2 - i32.shl + i32.const 4 i32.add - local.set $3 - loop $while-continue|00 - local.get $1 - local.get $3 - i32.lt_u - if - local.get $1 - i32.load - local.tee $2 - if - local.get $2 - call $~lib/rt/itcms/__visit - end - local.get $1 - i32.const 4 - i32.add - local.set $1 - br $while-continue|00 - end - end - br $folding-inner8 + global.set $~lib/memory/__stack_pointer + return end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner7 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer local.get $0 - i32.store + i32.load + call $~lib/rt/itcms/__visit local.get $0 i32.load offset=4 call $~lib/rt/itcms/__visit - br $folding-inner9 + return end local.get $0 - i32.load offset=4 + i32.load call $~lib/rt/itcms/__visit return end local.get $0 i32.load offset=4 call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - call $~lib/rt/itcms/__visit return end local.get $0 - i32.load + i32.load offset=4 call $~lib/rt/itcms/__visit local.get $0 - i32.load offset=4 + i32.load offset=8 call $~lib/rt/itcms/__visit return end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + local.get $0 + i32.load offset=16 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=20 + call $~lib/rt/itcms/__visit + local.get $0 + i32.load offset=24 + call $~lib/rt/itcms/__visit + return end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - call $~lib/rt/itcms/__visit + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable end global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + call $~lib/rt/itcms/__visit + global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer @@ -3752,7 +3824,7 @@ memory.size i32.const 16 i32.shl - i32.const 54068 + i32.const 54532 i32.sub i32.const 1 i32.shr_u @@ -3787,11 +3859,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3828,11 +3900,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3892,11 +3964,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3945,11 +4017,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3977,11 +4049,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4093,11 +4165,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4141,11 +4213,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4257,11 +4329,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4295,7 +4367,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -4307,7 +4379,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -4370,8 +4442,8 @@ local.get $2 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4385,11 +4457,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4448,11 +4520,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4479,11 +4551,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4527,11 +4599,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4574,11 +4646,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4632,11 +4704,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4702,11 +4774,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4773,11 +4845,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4822,11 +4894,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4877,11 +4949,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4961,11 +5033,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -5027,11 +5099,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -5098,7 +5170,7 @@ select local.set $1 end - block $__inlined_func$~lib/rt/itcms/__renew$2366 + block $__inlined_func$~lib/rt/itcms/__renew$2434 local.get $4 i32.const 20 i32.sub @@ -5116,7 +5188,7 @@ i32.store offset=16 local.get $4 local.set $2 - br $__inlined_func$~lib/rt/itcms/__renew$2366 + br $__inlined_func$~lib/rt/itcms/__renew$2434 end local.get $1 local.get $3 @@ -5165,11 +5237,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -5235,11 +5307,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7038,11 +7110,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7099,7 +7171,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -7120,7 +7192,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -7216,8 +7288,8 @@ local.get $1 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7230,11 +7302,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7284,11 +7356,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7338,11 +7410,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7387,11 +7459,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7441,11 +7513,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7511,11 +7583,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7576,11 +7648,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7643,11 +7715,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7708,11 +7780,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7775,11 +7847,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7840,11 +7912,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7907,11 +7979,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7974,11 +8046,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8041,11 +8113,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8109,11 +8181,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8197,11 +8269,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8240,11 +8312,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8305,11 +8377,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8370,11 +8442,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8435,11 +8507,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8500,11 +8572,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8565,11 +8637,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8629,11 +8701,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8691,11 +8763,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8753,11 +8825,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8815,11 +8887,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8878,11 +8950,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8955,11 +9027,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9032,11 +9104,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9109,11 +9181,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9186,11 +9258,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9263,11 +9335,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9338,11 +9410,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9369,11 +9441,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9411,11 +9483,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9461,11 +9533,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9515,11 +9587,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9589,11 +9661,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9648,11 +9720,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9697,11 +9769,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9771,11 +9843,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9834,11 +9906,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9907,11 +9979,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9968,11 +10040,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10035,11 +10107,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10076,11 +10148,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10146,11 +10218,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10193,7 +10265,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -10220,7 +10292,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -10273,8 +10345,8 @@ local.get $0 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10287,11 +10359,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10348,7 +10420,7 @@ if i32.const 10512 i32.const 10640 - i32.const 42 + i32.const 46 i32.const 12 call $~lib/builtins/abort unreachable @@ -10373,7 +10445,7 @@ block $folding-inner2 block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -10400,7 +10472,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -10428,7 +10500,7 @@ i32.load offset=8 local.tee $8 i32.store - block $__inlined_func$assembly/memory/Memory#getPage$2371 (result i32) + block $__inlined_func$assembly/memory/Memory#getPage$2439 (result i32) local.get $8 local.get $6 call $"~lib/map/Map#has" @@ -10448,7 +10520,7 @@ local.get $7 local.get $5 call $assembly/memory/PageData#constructor - br $__inlined_func$assembly/memory/Memory#getPage$2371 + br $__inlined_func$assembly/memory/Memory#getPage$2439 end global.get $~lib/memory/__stack_pointer local.get $0 @@ -10494,7 +10566,7 @@ local.get $7 local.get $5 call $assembly/memory/PageData#constructor - br $__inlined_func$assembly/memory/Memory#getPage$2371 + br $__inlined_func$assembly/memory/Memory#getPage$2439 end global.get $~lib/memory/__stack_pointer global.get $assembly/memory/NO_PAGE_FAULT @@ -10736,8 +10808,8 @@ i32.store br $folding-inner2 end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10761,11 +10833,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10821,11 +10893,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10876,7 +10948,7 @@ block $folding-inner1 block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -10920,7 +10992,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -10975,7 +11047,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -11076,8 +11148,8 @@ local.set $0 br $folding-inner1 end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11097,11 +11169,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11160,11 +11232,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11206,11 +11278,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11295,11 +11367,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11365,11 +11437,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11452,11 +11524,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11543,11 +11615,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11631,11 +11703,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11748,11 +11820,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11835,11 +11907,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11942,11 +12014,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12030,11 +12102,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12201,11 +12273,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12289,11 +12361,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12423,11 +12495,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12511,11 +12583,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12790,11 +12862,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12878,11 +12950,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12987,11 +13059,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13096,11 +13168,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13205,11 +13277,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13314,11 +13386,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13423,11 +13495,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13532,11 +13604,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13641,11 +13713,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13714,11 +13786,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13787,11 +13859,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13860,11 +13932,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13945,11 +14017,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14030,11 +14102,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14115,11 +14187,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14202,11 +14274,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14289,11 +14361,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14377,11 +14449,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14449,11 +14521,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14523,11 +14595,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14595,11 +14667,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14664,11 +14736,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14737,11 +14809,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14806,11 +14878,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14892,11 +14964,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14982,11 +15054,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15068,11 +15140,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15176,11 +15248,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15311,11 +15383,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15420,11 +15492,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15557,11 +15629,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15642,11 +15714,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15727,11 +15799,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15812,11 +15884,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15937,11 +16009,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16070,11 +16142,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16212,11 +16284,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16351,11 +16423,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16575,11 +16647,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16711,11 +16783,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16743,7 +16815,7 @@ i64.const 13 i64.ge_u select - block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2376 (result i64) + block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2444 (result i64) global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 @@ -16844,7 +16916,7 @@ i64.const -1 i64.xor i64.add - br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2376 + br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2444 end local.get $3 i64.const 4294967295 @@ -16910,11 +16982,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16997,11 +17069,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17084,11 +17156,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17171,11 +17243,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17249,611 +17321,962 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/mov~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) + (func $start:assembly/instructions/misc~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.eqz - if + block $folding-inner0 global.get $~lib/memory/__stack_pointer - local.get $1 + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $0 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 local.get $0 - i64.load32_u offset=4 - local.set $3 + i32.const 3 + i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 + local.get $0 + i32.const 3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer local.get $0 - i64.load32_s offset=8 - call $~lib/staticarray/StaticArray#__set + return end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable ) - (func $start:assembly/instructions/mov~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) + (func $~lib/array/Array#get:length (param $0 i32) (result i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 + i32.const 0 i32.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 + i32.store local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor + i32.load offset=12 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/mov~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) + (func $~lib/console/console.log (param $0 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 i32.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 + i32.store local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.eqz - if + call $~lib/bindings/dom/console.log + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory-page/Arena#acquire (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store local.get $1 - i32.store offset=4 + call $~lib/array/Array#get:length + i32.const 0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load offset=12 + local.tee $0 + i32.const 0 + i32.le_s + if + i32.const 12448 + i32.const 9152 + i32.const 271 + i32.const 18 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.get $0 + i32.const 1 + i32.sub + local.tee $0 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=8 - local.get $1 + i32.store + local.get $0 + i32.load offset=8 i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select + i32.shl + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store local.get $1 - i32.const 12 local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if + i32.load offset=4 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 12496 + i32.store + i32.const 12496 + call $~lib/console/console.log + end global.get $~lib/memory/__stack_pointer local.get $1 + i32.const 536870912 + i32.lt_u + if (result i32) + i32.const 4096 + call $~lib/typedarray/Uint8Array#constructor + else + i32.const 0 + end + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 local.get $0 - i64.load32_u offset=8 - local.set $3 + local.get $0 + i32.load offset=8 + i32.const 1 + i32.add + i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $0 i32.store offset=4 - global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=8 + i32.load offset=8 + global.get $~lib/memory/__stack_pointer local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select + i32.store local.get $1 + call $assembly/memory-page/RawPage#constructor + global.get $~lib/memory/__stack_pointer i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set + i32.add + global.set $~lib/memory/__stack_pointer + return end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable ) - (func $start:assembly/instructions/rot~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) + (func $"~lib/map/Map#set" (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.rotr - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $1 + i32.const -1028477379 + i32.mul + i32.const 374761397 + i32.add + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.tee $3 + local.get $3 + i32.const 15 + i32.shr_u + i32.xor + i32.const -2048144777 + i32.mul + local.tee $3 + local.get $3 + i32.const 13 + i32.shr_u + i32.xor + i32.const -1028477379 + i32.mul + local.tee $3 + local.get $3 + i32.const 16 + i32.shr_u + i32.xor + local.tee $8 + call $"~lib/map/Map#find" + local.tee $3 + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $3 + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=12 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=12 + i32.const 3 + i32.mul + i32.const 4 + i32.div_s + i32.lt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + i32.const 1 + i32.shl + i32.const 1 + i32.or + end + local.set $9 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.shl + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $10 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.const 3 + i32.shl + i32.const 3 + i32.div_s + local.tee $7 + i32.const 12 + i32.mul + call $~lib/arraybuffer/ArrayBuffer#constructor + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=8 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $11 + local.get $0 + i32.load offset=16 + i32.const 12 + i32.mul + i32.add + local.set $6 + local.get $4 + local.set $3 + loop $while-continue|0 + local.get $6 + local.get $11 + i32.ne + if + local.get $11 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if + local.get $3 + local.get $11 + i32.load + local.tee $12 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.load offset=4 + local.tee $5 + i32.store offset=8 + local.get $3 + local.get $5 + i32.store offset=4 + local.get $3 + local.get $10 + local.get $9 + local.get $12 + i32.const -1028477379 + i32.mul + i32.const 374761397 + i32.add + i32.const 17 + i32.rotl + i32.const 668265263 + i32.mul + local.tee $5 + i32.const 15 + i32.shr_u + local.get $5 + i32.xor + i32.const -2048144777 + i32.mul + local.tee $5 + i32.const 13 + i32.shr_u + local.get $5 + i32.xor + i32.const -1028477379 + i32.mul + local.tee $5 + i32.const 16 + i32.shr_u + local.get $5 + i32.xor + i32.and + i32.const 2 + i32.shl + i32.add + local.tee $5 + i32.load + i32.store offset=8 + local.get $5 + local.get $3 + i32.store + local.get $3 + i32.const 12 + i32.add + local.set $3 + end + local.get $11 + i32.const 12 + i32.add + local.set $11 + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $0 + local.get $10 + i32.store + local.get $0 + local.get $10 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $0 + local.get $4 + i32.store offset=8 + local.get $0 + local.get $4 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + local.get $7 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $0 + local.get $0 + i32.load offset=20 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=16 + local.tee $4 + i32.const 1 + i32.add + i32.store offset=16 + local.get $3 + local.get $4 + i32.const 12 + i32.mul + i32.add + local.tee $3 + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $3 + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 + i32.load offset=20 + i32.const 1 + i32.add + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $3 + local.get $1 + local.get $8 + local.get $0 + i32.load offset=4 + i32.and + i32.const 2 + i32.shl + i32.add + local.tee $0 + i32.load + i32.store offset=8 + local.get $0 + local.get $3 + i32.store + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_s offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.rotr - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable ) - (func $start:assembly/instructions/rot~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/misc~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) - (local $4 i64) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $0 - i32.load offset=8 - i32.rotr - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + call $assembly/memory/Result#constructor + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $6 + local.get $2 + i64.load32_u offset=12 + i64.store + block $folding-inner0 + local.get $4 + i32.eqz + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i64.load32_u offset=12 + local.get $4 + i64.extend_i32_u + i64.add + local.tee $3 + i64.const 4294967296 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=8 + local.tee $2 + i32.store offset=4 + local.get $2 + i32.const 1 + i32.store8 + br $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $3 + i64.store32 offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $3 + i64.const 1 + i64.sub + i64.const 12 + i64.shr_s + i32.wrap_i64 + local.tee $5 + local.get $2 + i32.load + i32.eq + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.load + i32.const 1 + i32.add + local.set $4 + loop $for-loop|0 + local.get $4 + local.get $5 + i32.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + local.tee $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + call $assembly/memory-page/Arena#acquire + local.tee $7 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + i32.const 2 + local.get $7 + call $assembly/memory-page/Page#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $8 + local.get $4 + local.get $7 + call $"~lib/map/Map#set" + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $5 + i32.store + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $4 + i32.store + local.get $4 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/instructions/outcome/okOrFault + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 + i64.load + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable ) - (func $start:assembly/instructions/rot~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/mov~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17875,12 +18298,6 @@ i64.load32_u offset=4 local.set $3 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=8 - local.set $2 - global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 global.get $~lib/memory/__stack_pointer @@ -17894,7 +18311,6 @@ i64.const 13 i64.ge_u select - local.get $2 local.get $1 i32.const 12 local.get $0 @@ -17906,9 +18322,6 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.rotr - i64.extend_i32_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -17916,19 +18329,18 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/rot~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/mov~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) - (local $4 i64) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17938,50 +18350,80 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 local.get $1 i32.const 12 local.get $0 - i64.load32_u offset=4 - local.tee $4 + i64.load32_u + local.tee $3 i32.wrap_i64 - local.get $4 + local.get $3 i64.const 13 i64.ge_u select call $~lib/staticarray/StaticArray#__get - local.set $4 + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + call $~lib/staticarray/StaticArray#__set + end + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/mov~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 + i32.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 + i32.store offset=4 local.get $1 i32.const 12 local.get $0 @@ -17993,27 +18435,51 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i64.rotl - call $~lib/staticarray/StaticArray#__set + i64.const 0 + i64.ne + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + call $~lib/staticarray/StaticArray#__set + end call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/rot~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/mov~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) - (local $4 i64) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18031,43 +18497,6 @@ global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $2 local.get $1 i32.const 12 local.get $0 @@ -18079,29 +18508,62 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.rotl - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set + i64.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer i32.const 12 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/rot~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/mov~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) - (local $4 i64) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18119,42 +18581,6 @@ global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 local.get $1 i32.const 12 local.get $0 @@ -18166,15 +18592,52 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i64.rotr - call $~lib/staticarray/StaticArray#__set + i64.const 0 + i64.ne + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + call $~lib/staticarray/StaticArray#__set + end call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer i32.const 12 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/rot~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/rot~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) (local $4 i64) global.get $~lib/memory/__stack_pointer @@ -18182,11 +18645,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18205,8 +18668,8 @@ local.get $0 i32.store offset=4 local.get $0 - i64.load32_u offset=8 - local.set $4 + i64.load32_u offset=4 + local.set $3 global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 @@ -18216,45 +18679,30 @@ local.get $1 i32.const 12 local.get $0 - i64.load32_u offset=4 - local.tee $3 + i64.load32_u + local.tee $4 i32.wrap_i64 - local.get $3 + local.get $4 i64.const 13 i64.ge_u select call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 + local.set $4 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $2 + i32.store offset=4 local.get $1 i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 + local.get $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.rotr - i64.extend_i32_s + local.get $4 + local.get $0 + i64.load32_s offset=8 + i64.rotr call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -18262,18 +18710,19 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/set~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/rot~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) + (local $4 i64) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18283,66 +18732,70 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $1 - i32.const 12 local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get + i64.load32_u offset=4 + local.set $3 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store + i32.store offset=4 local.get $0 i64.load32_s offset=8 - i64.lt_u - local.set $2 + local.set $4 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 local.get $1 i32.const 12 local.get $0 - i64.load32_u offset=4 + i64.load32_u local.tee $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select - local.get $2 - i64.extend_i32_u + call $~lib/staticarray/StaticArray#__get + i64.rotr call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/set~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/rot~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) + (local $4 i64) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18352,66 +18805,71 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 local.get $1 i32.const 12 local.get $0 i64.load32_u - local.tee $3 + local.tee $4 i32.wrap_i64 - local.get $3 + local.get $4 i64.const 13 i64.ge_u select call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.lt_s + i32.wrap_i64 local.set $2 global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 local.get $1 i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 + local.get $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select local.get $2 - i64.extend_i32_u + local.get $0 + i32.load offset=8 + i32.rotr + i64.extend_i32_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/set~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/rot~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18421,66 +18879,72 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $1 - i32.const 12 local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get + i64.load32_u offset=4 + local.set $3 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store + i32.store offset=4 local.get $0 - i64.load32_s offset=8 - i64.gt_u + i32.load offset=8 local.set $2 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $2 local.get $1 i32.const 12 local.get $0 - i64.load32_u offset=4 + i64.load32_u local.tee $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select - local.get $2 - i64.extend_i32_u + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.rotr + i64.extend_i32_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/set~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/rot~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) + (local $4 i64) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18490,55 +18954,70 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 local.get $1 i32.const 12 local.get $0 - i64.load32_u - local.tee $3 + i64.load32_u offset=4 + local.tee $4 i32.wrap_i64 - local.get $3 + local.get $4 i64.const 13 i64.ge_u select call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.gt_s - local.set $2 + local.set $4 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 local.get $1 i32.const 12 local.get $0 - i64.load32_u offset=4 + i64.load32_u local.tee $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select - local.get $2 - i64.extend_i32_u + call $~lib/staticarray/StaticArray#__get + i64.rotl call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/set~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/rot~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) (local $4 i64) global.get $~lib/memory/__stack_pointer @@ -18546,11 +19025,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18570,7 +19049,7 @@ i32.store offset=4 local.get $0 i64.load32_u offset=8 - local.set $3 + local.set $4 global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 @@ -18581,14 +19060,15 @@ i32.const 12 local.get $0 i64.load32_u offset=4 - local.tee $4 + local.tee $3 i32.wrap_i64 - local.get $4 + local.get $3 i64.const 13 i64.ge_u select call $~lib/staticarray/StaticArray#__get - local.set $4 + i32.wrap_i64 + local.set $2 global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 @@ -18597,12 +19077,13 @@ i32.store offset=8 local.get $1 i32.const 12 - local.get $3 + local.get $4 i32.wrap_i64 - local.get $3 + local.get $4 i64.const 13 i64.ge_u select + local.get $2 local.get $1 i32.const 12 local.get $0 @@ -18614,9 +19095,9 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.gt_u - i64.extend_i32_u + i32.wrap_i64 + i32.rotl + i64.extend_i32_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -18624,7 +19105,7 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/set~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/rot~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) (local $4 i64) global.get $~lib/memory/__stack_pointer @@ -18632,11 +19113,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18689,6 +19170,7 @@ i64.const 13 i64.ge_u select + local.get $4 local.get $1 i32.const 12 local.get $0 @@ -18700,9 +19182,7 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.gt_s - i64.extend_i32_u + i64.rotr call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -18710,19 +19190,19 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/rot~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) - (local $4 i32) + (local $4 i64) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18732,23 +19212,27 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 31 - i32.and - local.set $2 + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 local.get $1 i32.const 12 local.get $0 - i64.load32_u + i64.load32_u offset=4 local.tee $3 i32.wrap_i64 local.get $3 @@ -18757,47 +19241,55 @@ select call $~lib/staticarray/StaticArray#__get i32.wrap_i64 - local.set $4 + local.set $2 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + local.get $2 local.get $1 i32.const 12 local.get $0 - i64.load32_u offset=4 + i64.load32_u local.tee $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select - local.get $4 - local.get $2 - i32.shl + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + i32.rotr i64.extend_i32_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/set~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) - (local $4 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18807,14 +19299,6 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 31 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer @@ -18831,8 +19315,13 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.lt_u + local.set $2 global.get $~lib/memory/__stack_pointer local.get $1 i32.store @@ -18849,10 +19338,8 @@ i64.const 13 i64.ge_u select - local.get $4 local.get $2 - i32.shr_u - i64.extend_i32_s + i64.extend_i32_u call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -18860,19 +19347,18 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/set~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) - (local $4 i64) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18882,14 +19368,6 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 31 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer @@ -18906,8 +19384,13 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i64.extend32_s - local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.lt_s + local.set $2 global.get $~lib/memory/__stack_pointer local.get $1 i32.store @@ -18924,10 +19407,8 @@ i64.const 13 i64.ge_u select - local.get $4 local.get $2 i64.extend_i32_u - i64.shr_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -18935,18 +19416,18 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/set~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18972,9 +19453,12 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.gt_u local.set $2 global.get $~lib/memory/__stack_pointer local.get $1 @@ -18982,25 +19466,18 @@ global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 local.get $1 i32.const 12 - local.get $3 + local.get $0 + i64.load32_u offset=4 + local.tee $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select - local.get $0 - i32.load offset=8 local.get $2 - i32.shl - i64.extend_i32_s + i64.extend_i32_u call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -19008,18 +19485,18 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/set~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19045,9 +19522,12 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + i64.gt_s local.set $2 global.get $~lib/memory/__stack_pointer local.get $1 @@ -19055,25 +19535,18 @@ global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 local.get $1 i32.const 12 - local.get $3 + local.get $0 + i64.load32_u offset=4 + local.tee $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select - local.get $0 - i32.load offset=8 local.get $2 - i32.shr_u - i64.extend_i32_s + i64.extend_i32_u call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -19081,19 +19554,19 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/set~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) (local $4 i64) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19103,72 +19576,83 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 local.get $1 i32.const 12 local.get $0 - i64.load32_u - local.tee $3 + i64.load32_u offset=4 + local.tee $4 i32.wrap_i64 - local.get $3 + local.get $4 i64.const 13 i64.ge_u select call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 local.set $4 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + i32.store offset=8 local.get $1 i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 + local.get $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select - local.get $4 - local.get $2 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.get $4 + i64.gt_u i64.extend_i32_u - i64.shr_s - i64.extend32_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/set~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) + (local $4 i64) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19181,22 +19665,32 @@ i32.const 0 i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $1 i32.store + global.get $~lib/memory/__stack_pointer local.get $0 - i32.load offset=8 - i32.const 63 - i32.and - local.set $2 + i32.store offset=4 + local.get $0 + i64.load32_u offset=8 + local.set $3 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + i32.store offset=8 + local.get $1 + i32.const 12 local.get $0 i64.load32_u offset=4 - local.set $3 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + local.set $4 global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 @@ -19222,9 +19716,9 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - local.get $2 + local.get $4 + i64.gt_s i64.extend_i32_u - i64.shl call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -19232,18 +19726,19 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19253,14 +19748,11 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer local.get $0 i32.store local.get $0 i32.load offset=8 - i32.const 63 + i32.const 31 i32.and local.set $2 global.get $~lib/memory/__stack_pointer @@ -19269,23 +19761,81 @@ global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 + local.get $1 + i32.const 12 local.get $0 - i64.load32_u offset=4 - local.set $3 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 + i32.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=8 + i32.store offset=4 local.get $1 i32.const 12 - local.get $3 + local.get $0 + i64.load32_u offset=4 + local.tee $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select + local.get $4 + local.get $2 + i32.shl + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 31 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 local.get $1 i32.const 12 local.get $0 @@ -19297,17 +19847,36 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 local.get $2 - i64.extend_i32_u - i64.shr_u + i32.shr_u + i64.extend_i32_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) (local $4 i64) global.get $~lib/memory/__stack_pointer @@ -19315,11 +19884,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19333,7 +19902,7 @@ i32.store local.get $0 i32.load offset=8 - i32.const 63 + i32.const 31 i32.and local.set $2 global.get $~lib/memory/__stack_pointer @@ -19353,6 +19922,7 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get + i64.extend32_s local.set $4 global.get $~lib/memory/__stack_pointer local.get $1 @@ -19381,18 +19951,18 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19418,7 +19988,7 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i64.const 63 + i64.const 31 i64.and i32.wrap_i64 local.set $2 @@ -19443,10 +20013,10 @@ i64.ge_u select local.get $0 - i64.load32_s offset=8 + i32.load offset=8 local.get $2 - i64.extend_i32_u - i64.shl + i32.shl + i64.extend_i32_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -19454,18 +20024,18 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19491,7 +20061,7 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i64.const 63 + i64.const 31 i64.and i32.wrap_i64 local.set $2 @@ -19516,10 +20086,10 @@ i64.ge_u select local.get $0 - i64.load32_s offset=8 + i32.load offset=8 local.get $2 - i64.extend_i32_u - i64.shr_u + i32.shr_u + i64.extend_i32_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -19527,7 +20097,7 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) (local $4 i64) global.get $~lib/memory/__stack_pointer @@ -19535,11 +20105,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19565,7 +20135,7 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i64.const 63 + i64.const 31 i64.and i32.wrap_i64 local.set $2 @@ -19603,19 +20173,18 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) - (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19625,25 +20194,15 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 + i32.store local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 + i32.load offset=8 + i32.const 63 + i32.and local.set $2 global.get $~lib/memory/__stack_pointer local.get $1 @@ -19651,59 +20210,56 @@ global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $1 - i32.const 12 local.get $0 i64.load32_u offset=4 - local.tee $3 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 local.get $1 i32.const 12 local.get $0 - i64.load32_u offset=8 + i64.load32_u local.tee $3 i32.wrap_i64 local.get $3 i64.const 13 i64.ge_u select - local.get $4 + call $~lib/staticarray/StaticArray#__get local.get $2 - i32.shl - i64.extend_i32_s + i64.extend_i32_u + i64.shl call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) - (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19713,11 +20269,39 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 63 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select local.get $1 i32.const 12 local.get $0 @@ -19729,9 +20313,44 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 + local.get $2 + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=8 + i32.const 63 + i32.and local.set $2 global.get $~lib/memory/__stack_pointer local.get $1 @@ -19742,7 +20361,7 @@ local.get $1 i32.const 12 local.get $0 - i64.load32_u offset=4 + i64.load32_u local.tee $3 i32.wrap_i64 local.get $3 @@ -19750,7 +20369,6 @@ i64.ge_u select call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 local.set $4 global.get $~lib/memory/__stack_pointer local.get $1 @@ -19761,7 +20379,7 @@ local.get $1 i32.const 12 local.get $0 - i64.load32_u offset=8 + i64.load32_u offset=4 local.tee $3 i32.wrap_i64 local.get $3 @@ -19770,8 +20388,8 @@ select local.get $4 local.get $2 - i32.shr_u - i64.extend_i32_s + i64.extend_i32_u + i64.shr_s call $~lib/staticarray/StaticArray#__set call $assembly/instructions/outcome/OutcomeData#constructor global.get $~lib/memory/__stack_pointer @@ -19779,19 +20397,417 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/shift~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $start:assembly/instructions/shift~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i64) - (local $4 i64) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + local.get $2 + i64.extend_i32_u + i64.shl + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i64.load32_u offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $0 + i64.load32_s offset=8 + local.get $2 + i64.extend_i32_u + i64.shr_u + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 63 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i64.load32_s offset=8 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i64.extend_i32_u + i64.shr_s + i64.extend32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.shl + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.const 31 + i64.and + i32.wrap_i64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=4 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + i32.const 12 + local.get $0 + i64.load32_u offset=8 + local.tee $3 + i32.wrap_i64 + local.get $3 + i64.const 13 + i64.ge_u + select + local.get $4 + local.get $2 + i32.shr_u + i64.extend_i32_s + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/OutcomeData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/instructions/shift~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i64) + (local $4 i64) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19875,11 +20891,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19963,11 +20979,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20051,11 +21067,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20138,11 +21154,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20186,11 +21202,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20265,11 +21281,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20319,11 +21335,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20445,11 +21461,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20501,11 +21517,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20648,11 +21664,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20702,11 +21718,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20851,11 +21867,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20905,11 +21921,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20974,11 +21990,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21043,11 +22059,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21110,11 +22126,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21175,11 +22191,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21249,11 +22265,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21323,11 +22339,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21395,11 +22411,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21468,11 +22484,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21556,11 +22572,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21644,11 +22660,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21730,11 +22746,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21807,87 +22823,243 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $start:assembly/instructions/misc~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + i32.load8_u + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $start:assembly/codec~anonymous|0 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15344 + i32.store + i32.const 15344 + call $~lib/array/Array#get:length + local.set $2 + loop $for-loop|0 local.get $1 - i32.store offset=16 + local.get $2 + i32.const 255 + i32.and + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + i32.const 15344 + i32.store + i32.const 15344 + local.get $1 + call $~lib/array/Array#__get + local.get $0 + i32.const 255 + i32.and + i32.le_u + if + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 8 + local.get $1 + i32.sub + return + end + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/Mask#isInstruction (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $2 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i64.extend_i32_s + local.get $1 + i64.extend_i32_u + i64.le_u + if global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 + i32.const 0 return end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + i32.eqz + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer ) - (func $~lib/array/Array#get:length (param $0 i32) (result i32) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21899,1565 +23071,1499 @@ global.get $~lib/memory/__stack_pointer local.get $0 i32.store + local.get $1 local.get $0 i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $0 + i32.eqz + if + i32.const 15728 + i32.const 9152 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer + local.get $0 ) - (func $~lib/console/console.log (param $0 i32) + (func $~lib/string/String#concat (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i32.const 0 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 i32.store + local.get $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + local.tee $3 + local.get $2 + i32.add + local.tee $4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15504 + return + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $4 + i32.store offset=4 + local.get $4 + local.get $0 + local.get $2 + memory.copy + local.get $2 + local.get $4 + i32.add + local.get $1 + local.get $3 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $~lib/string/String.__concat (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 local.get $0 - call $~lib/bindings/dom/console.log + local.get $1 + call $~lib/string/String#concat global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/memory-page/Arena#acquire (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) + (func $~lib/util/string/joinStringArray (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $1 + i32.const 1 + i32.sub + local.tee $5 + i32.const 0 + i32.lt_s + if global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15504 + return + end + local.get $5 + i32.eqz + if global.get $~lib/memory/__stack_pointer local.get $0 i32.load - local.tee $1 + local.tee $0 i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + i32.const 15504 + local.get $0 + select + return + end + loop $for-loop|0 local.get $1 - call $~lib/array/Array#get:length - i32.const 0 + local.get $4 i32.gt_s if global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load offset=12 - local.tee $0 - i32.const 0 - i32.le_s - if - i32.const 14144 - i32.const 9152 - i32.const 271 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.get $0 - i32.const 1 - i32.sub - local.tee $0 + local.get $4 i32.const 2 i32.shl i32.add i32.load - local.tee $2 + local.tee $6 i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $6 + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $3 + local.get $6 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + i32.add + local.set $3 + end + local.get $4 + i32.const 1 i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return + local.set $4 + br $for-loop|0 end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 12 - i32.shl - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.eq + end + i32.const 0 + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $2 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + local.tee $1 + local.get $5 + i32.mul + i32.add + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $6 + i32.store offset=12 + i32.const 0 + local.set $3 + loop $for-loop|1 + local.get $3 + local.get $5 + i32.lt_s if global.get $~lib/memory/__stack_pointer - i32.const 14192 - i32.store - i32.const 14192 - call $~lib/console/console.log - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 536870912 - i32.lt_u - if (result i32) - i32.const 4096 - call $~lib/typedarray/Uint8Array#constructor - else - i32.const 0 + local.get $0 + local.get $3 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $7 + i32.store offset=4 + local.get $7 + if + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $6 + local.get $4 + i32.const 1 + i32.shl + i32.add + local.get $7 + local.get $7 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + local.tee $7 + i32.const 1 + i32.shl + memory.copy + local.get $4 + local.get $7 + i32.add + local.set $4 + end + local.get $1 + if + local.get $6 + local.get $4 + i32.const 1 + i32.shl + i32.add + local.get $2 + local.get $1 + i32.const 1 + i32.shl + memory.copy + local.get $1 + local.get $4 + i32.add + local.set $4 + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 end - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store + end + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $5 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $0 + i32.store offset=4 + local.get $0 + if global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + i32.store offset=8 + local.get $6 + local.get $4 + i32.const 1 + i32.shl + i32.add local.get $0 local.get $0 - i32.load offset=8 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + memory.copy + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + ) + (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 i32.const 1 - i32.add - i32.store offset=8 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store + local.get $0 + local.get $1 + i32.const 15504 + call $~lib/util/string/joinStringArray + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/Mask#skipBytesToNextInstruction (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $1 + i32.const 1 + i32.add + local.tee $1 + local.get $2 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.lt_u + if global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $0 - i32.load offset=8 global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $0 + i32.load + local.tee $0 i32.store + local.get $0 local.get $1 - call $assembly/memory-page/RawPage#constructor + call $~lib/staticarray/StaticArray#__get global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer return end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 ) - (func $"~lib/map/Map#set" (param $0 i32) (param $1 i32) (param $2 i32) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + local.tee $0 + i32.store offset=4 + local.get $0 + i32.eqz + if + i32.const 15728 + i32.const 9152 + i32.const 118 + i32.const 40 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/program/decodeArguments (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i32) (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 1264 + i32.store + i32.const 1264 + local.get $0 + call $~lib/array/Array#__get + local.get $4 + i32.gt_s + if global.get $~lib/memory/__stack_pointer - local.get $0 + i32.const 1264 i32.store + global.get $~lib/memory/__stack_pointer + i32.const 1264 local.get $0 - local.get $1 - local.get $1 - i32.const -1028477379 - i32.mul - i32.const 374761397 - i32.add - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.tee $3 - local.get $3 - i32.const 15 - i32.shr_u - i32.xor - i32.const -2048144777 - i32.mul - local.tee $3 - local.get $3 - i32.const 13 - i32.shr_u - i32.xor - i32.const -1028477379 - i32.mul - local.tee $3 - local.get $3 - i32.const 16 - i32.shr_u - i32.xor - local.tee $8 - call $"~lib/map/Map#find" - local.tee $3 - if + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#constructor + local.tee $4 + i32.store offset=4 + loop $for-loop|0 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $1 i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length local.get $3 - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=12 - i32.eq + i32.gt_s if global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $4 i32.store global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=12 - i32.const 3 - i32.mul - i32.const 4 - i32.div_s - i32.lt_s - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - i32.const 1 - i32.shl - i32.const 1 - i32.or - end - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.shl - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $10 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.const 3 - i32.shl - i32.const 3 - i32.div_s - local.tee $7 - i32.const 12 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=8 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $11 - local.get $0 - i32.load offset=16 - i32.const 12 - i32.mul - i32.add - local.set $6 - local.get $4 - local.set $3 - loop $while-continue|0 - local.get $6 - local.get $11 - i32.ne - if - local.get $11 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - local.get $3 - local.get $11 - i32.load - local.tee $12 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=4 - local.tee $5 - i32.store offset=8 - local.get $3 - local.get $5 - i32.store offset=4 - local.get $3 - local.get $10 - local.get $9 - local.get $12 - i32.const -1028477379 - i32.mul - i32.const 374761397 - i32.add - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.tee $5 - i32.const 15 - i32.shr_u - local.get $5 - i32.xor - i32.const -2048144777 - i32.mul - local.tee $5 - i32.const 13 - i32.shr_u - local.get $5 - i32.xor - i32.const -1028477379 - i32.mul - local.tee $5 - i32.const 16 - i32.shr_u - local.get $5 - i32.xor - i32.and - i32.const 2 - i32.shl - i32.add - local.tee $5 - i32.load - i32.store offset=8 - local.get $5 - local.get $3 - i32.store - local.get $3 - i32.const 12 - i32.add - local.set $3 - end - local.get $11 - i32.const 12 - i32.add - local.set $11 - br $while-continue|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $0 - local.get $10 - i32.store - local.get $0 - local.get $10 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $0 - local.get $4 + local.get $1 i32.store offset=8 - local.get $0 local.get $4 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - local.get $7 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $0 - local.get $0 - i32.load offset=20 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 16 + local.get $3 + local.get $1 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $3 + i32.const 1 i32.add - global.set $~lib/memory/__stack_pointer + local.set $3 + br $for-loop|0 end + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + i32.const 2 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 2272 + i32.store offset=8 + local.get $4 + local.get $2 + i32.const 2272 + local.get $0 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $1) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 2 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + i32.const 2272 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 2272 + local.get $0 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + i32.load + call_indirect (type $1) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-internal/getAssembly (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15424 + return + end + i32.const 15504 + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store offset=8 + loop $for-loop|0 + local.get $3 + local.get $4 + i32.lt_s + if global.get $~lib/memory/__stack_pointer local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $3 - i32.store offset=8 + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 + i32.load offset=4 + local.tee $2 i32.store + local.get $2 + local.get $3 + call $assembly/program/Mask#isInstruction + i32.eqz + if + i32.const 15536 + i32.const 15648 + i32.const 48 + i32.const 7 + call $~lib/builtins/abort + unreachable + end global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 + global.get $~lib/memory/__stack_pointer local.get $0 - local.get $0 - i32.load offset=16 - local.tee $4 - i32.const 1 - i32.add - i32.store offset=16 + i32.load + local.tee $2 + i32.store + local.get $2 local.get $3 - local.get $4 - i32.const 12 - i32.mul - i32.add - local.tee $3 + call $~lib/typedarray/Uint8Array#__get + local.set $2 + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $5 + i32.store + local.get $2 + local.get $5 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $5 + i32.store + local.get $5 + local.get $2 + call $~lib/array/Array#__get + end + local.set $5 + global.get $~lib/memory/__stack_pointer local.get $1 i32.store global.get $~lib/memory/__stack_pointer - local.get $2 + i32.const 15856 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 15856 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 i32.store + global.get $~lib/memory/__stack_pointer local.get $3 - local.get $2 + call $~lib/number/I32#toString + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 17664 + i32.store offset=16 + local.get $7 + i32.const 17664 + call $~lib/string/String#concat + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 i32.store offset=4 - local.get $0 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link + local.get $1 + local.get $7 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $1 i32.store global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $5 + i32.load + local.tee $6 i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=20 - i32.const 1 - i32.add + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $6 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.const 255 + i32.and + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $2 i32.store offset=20 global.get $~lib/memory/__stack_pointer - local.get $0 + i32.const 17760 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + i32.const 17764 + local.get $2 i32.store + i32.const 17760 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 17760 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store offset=16 + i32.const 17760 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $1 + local.get $2 + call $~lib/string/String.__concat + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $0 - i32.load - local.set $1 + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 + i32.load offset=4 + local.tee $2 i32.store + local.get $2 local.get $3 - local.get $1 - local.get $8 - local.get $0 + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $5 i32.load offset=4 - i32.and - i32.const 2 - i32.shl - i32.add - local.tee $0 - i32.load - i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $8 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + local.get $8 local.get $3 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 i32.store - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $start:assembly/instructions/misc~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $6 - local.get $2 - i64.load32_u offset=12 - i64.store - block $folding-inner0 - local.get $4 - i32.eqz - br_if $folding-inner0 + local.get $8 + local.get $6 + call $assembly/program/decodeArguments + local.tee $2 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 2 + i32.const 38 + i32.const 0 + call $~lib/rt/__newArray + local.tee $8 + i32.store offset=28 global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=4 + i32.store + local.get $8 + i32.const 0 local.get $2 - i64.load32_u offset=12 - local.get $4 - i64.extend_i32_u - i64.add - local.tee $3 - i64.const 4294967296 - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=8 - local.tee $2 - i32.store offset=4 - local.get $2 - i32.const 1 - i32.store8 - br $folding-inner0 - end + i32.load + call $~lib/array/Array#__set global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=4 + i32.store + local.get $8 + i32.const 1 local.get $2 - local.get $3 - i64.store32 offset=12 + i32.load offset=4 + call $~lib/array/Array#__set global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=4 - local.get $3 - i64.const 1 - i64.sub - i64.const 12 - i64.shr_s - i32.wrap_i64 - local.tee $5 + i32.store + local.get $8 + i32.const 2 local.get $2 - i32.load - i32.eq - br_if $folding-inner0 + i32.load offset=8 + call $~lib/array/Array#__set global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=4 + i32.store + local.get $8 + i32.const 3 local.get $2 - i32.load - i32.const 1 - i32.add - local.set $4 - loop $for-loop|0 - local.get $4 + i32.load offset=12 + call $~lib/array/Array#__set + local.get $8 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 1136 + i32.store + i32.const 1136 + local.get $5 + i32.load offset=4 + call $~lib/array/Array#__get + local.set $5 + i32.const 0 + local.set $2 + loop $for-loop|1 + local.get $2 local.get $5 - i32.le_s + i32.lt_s if global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 + local.get $1 + i32.store global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - local.tee $7 - i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $7 - call $assembly/memory-page/Arena#acquire - local.tee $7 + local.get $8 i32.store offset=12 global.get $~lib/memory/__stack_pointer + local.get $8 local.get $2 + call $~lib/array/Array#__get + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $9 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + i32.const 17856 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $9 i32.store offset=16 + i32.const 17860 + local.get $9 + i32.store + i32.const 17856 + local.get $9 + i32.const 1 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $8 - i32.store offset=4 + i32.const 17856 + i32.store offset=12 global.get $~lib/memory/__stack_pointer - local.get $7 + i32.const 15504 i32.store offset=16 - i32.const 2 - local.get $7 - call $assembly/memory-page/Page#constructor - local.set $7 + i32.const 17856 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $9 global.get $~lib/memory/__stack_pointer - local.get $7 + local.get $9 + i32.store offset=4 + local.get $1 + local.get $9 + call $~lib/string/String.__concat + local.tee $1 i32.store offset=8 - local.get $8 - local.get $4 - local.get $7 - call $"~lib/map/Map#set" - local.get $4 + local.get $2 i32.const 1 i32.add - local.set $4 - br $for-loop|0 + local.set $2 + br $for-loop|1 end end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $5 - i32.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 + local.get $3 + local.get $6 i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - i32.load8_u - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/codec~anonymous|0 (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15344 - i32.store - i32.const 15344 - call $~lib/array/Array#get:length - local.set $2 - loop $for-loop|0 - local.get $1 - local.get $2 - i32.const 255 - i32.and - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - i32.const 15344 - i32.store - i32.const 15344 - local.get $1 - call $~lib/array/Array#__get - local.get $0 - i32.const 255 - i32.and - i32.le_u - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 8 - local.get $1 - i32.sub - return - end - local.get $1 i32.const 1 i32.add - local.set $1 + local.set $3 br $for-loop|0 end end global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 40 i32.add global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $assembly/program/liftBytes (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - call $~lib/array/Array#get:length - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.lt_s - if - i32.const 1504 - i32.const 1744 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=4 - local.get $2 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + local.get $1 ) - (func $assembly/codec/Decoder#constructor (param $0 i32) (result i32) - (local $1 i32) + (func $assembly/program-build/skipBytes (param $0 i32) (param $1 i32) (result i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 24 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 38 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/util/string/joinStringArray (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $1 - i32.const 1 - i32.sub - local.tee $5 - i32.const 0 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15424 - return - end - local.get $5 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - i32.const 15424 - local.get $0 - select - return - end - loop $for-loop|0 - local.get $1 - local.get $4 - i32.gt_s - if + i32.const 24 + memory.fill + block $folding-inner3 (result i32) + block $folding-inner2 + block $folding-inner1 + block $folding-inner0 + block $case13|0 + block $case12|0 + block $case11|0 + block $case8|0 + block $case7|0 + block $case6|0 + block $case5|0 + block $case4|0 + block $case2|0 + block $case0|0 + local.get $0 + br_table $case0|0 $folding-inner0 $case2|0 $folding-inner0 $case4|0 $case5|0 $case6|0 $case7|0 $case8|0 $folding-inner2 $folding-inner2 $case11|0 $case12|0 $case13|0 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u + i32.const 1 + i32.add + local.tee $0 + i32.const 255 + i32.and + i32.const 1 + i32.add + block $__inlined_func$assembly/program-build/immBytes$1606 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $1 + local.get $0 + i32.const 1 + i32.add + i32.const 255 + i32.and + local.tee $0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$1606 + drop + local.get $1 + local.get $0 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.add + br $folding-inner3 + end + block $__inlined_func$assembly/program-build/immBytes$1608 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $0 + i32.const 0 + i32.le_s + br_if $__inlined_func$assembly/program-build/immBytes$1608 + drop + local.get $0 + i32.const 1 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.const 1 + i32.add + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 9 + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=8 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=12 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 1 + return + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 1 + call $~lib/typedarray/Uint8Array#__get + call $assembly/arguments/nibbles + local.tee $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load8_u + i32.const 1 + i32.add + local.tee $0 + i32.const 255 + i32.and + i32.const 2 + i32.add + block $__inlined_func$assembly/program-build/immBytes$1614 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $1 + local.get $0 + i32.const 255 + i32.and + i32.const 2 + i32.add + local.tee $0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$1614 + drop + local.get $1 + local.get $0 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + i32.add + br $folding-inner3 + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 2 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 17888 + i32.store + local.get $0 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + i32.const 17888 + local.get $0 + call $~lib/string/String#concat + i32.const 17968 + i32.const 73 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + block $__inlined_func$assembly/program-build/immBytes$1604 (result i32) + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + i32.const 0 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.tee $0 + i32.const 0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$1604 + drop + local.get $0 + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s + end + br $folding-inner3 + end global.get $~lib/memory/__stack_pointer local.get $0 - local.get $4 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $6 - i32.store offset=4 - local.get $6 - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $3 - local.get $6 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - i32.add - local.set $3 - end - local.get $4 + i32.store + local.get $0 + i32.load8_u offset=1 i32.const 1 i32.add - local.set $4 - br $for-loop|0 - end - end - i32.const 0 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $2 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - local.tee $1 - local.get $5 - i32.mul - i32.add - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $6 - i32.store offset=12 - i32.const 0 - local.set $3 - loop $for-loop|1 - local.get $3 - local.get $5 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $3 - i32.const 2 - i32.shl + local.tee $0 + i32.const 255 + i32.and + i32.const 1 i32.add - i32.load - local.tee $7 - i32.store offset=4 - local.get $7 - if + block $__inlined_func$assembly/program-build/immBytes$1610 (result i32) global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $6 - local.get $4 - i32.const 1 - i32.shl - i32.add - local.get $7 - local.get $7 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - local.tee $7 - i32.const 1 - i32.shl - memory.copy - local.get $4 - local.get $7 - i32.add - local.set $4 - end - local.get $1 - if - local.get $6 - local.get $4 - i32.const 1 - i32.shl - i32.add - local.get $2 local.get $1 - i32.const 1 - i32.shl - memory.copy + i32.store + i32.const 0 local.get $1 - local.get $4 + call $~lib/typedarray/Uint8Array#get:length + local.tee $1 + local.get $0 + i32.const 255 + i32.and + i32.const 1 i32.add - local.set $4 + local.tee $0 + i32.lt_s + br_if $__inlined_func$assembly/program-build/immBytes$1610 + drop + local.get $1 + local.get $0 + i32.sub + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s end - local.get $3 - i32.const 1 i32.add - local.set $3 - br $for-loop|1 + br $folding-inner3 end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $5 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $0 - i32.store offset=4 - local.get $0 - if global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $6 - local.get $4 + local.get $1 + i32.store + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + f64.convert_i32_s + f64.const 4 + f64.min + i32.trunc_sat_f64_s i32.const 1 - i32.shl i32.add - local.get $0 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - memory.copy end global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 24 i32.add global.set $~lib/memory/__stack_pointer - local.get $6 ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $0 i32) (result i32) - (local $1 i32) + (func $~lib/array/Array#push (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + i32.const 0 + i32.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 15424 i32.store local.get $0 - local.get $1 - i32.const 15424 - call $~lib/util/string/joinStringArray - global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $0 + i32.load offset=12 + local.tee $2 + i32.const 1 i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/Decoder#ensureBytes (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 + local.tee $3 + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity global.get $~lib/memory/__stack_pointer local.get $0 i32.store - local.get $1 + local.get $2 local.get $0 i32.load offset=4 i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 + local.get $1 + i32.store8 global.get $~lib/memory/__stack_pointer local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - call $~lib/typedarray/Uint8Array#get:length - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - i32.sub - call $~lib/number/I32#toString - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 15584 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 15588 - local.get $1 - i32.store - i32.const 15584 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 15584 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 15596 - local.get $0 - i32.store - i32.const 15584 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 15584 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=4 - i32.const 15584 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 17408 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/ValOffset#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 40 - call $~lib/rt/itcms/__new - local.tee $2 i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $1 - i32.store offset=4 + local.get $3 + i32.store offset=12 global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 ) - (func $assembly/codec/Decoder#varU32 (param $0 i32) (result i32) + (func $assembly/program-build/buildMask (param $0 i32) (result i32) (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) - (local $5 i32) - (local $6 i32) global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -23467,601 +24573,724 @@ i64.const 0 i64.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=4 - local.set $4 - i32.const 1 - global.set $~argumentsLength - local.get $1 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 i32.const 0 - call $~lib/typedarray/Uint8Array#__get - i32.const 1 - global.set $~argumentsLength - i32.const 15392 - i32.load - call_indirect (type $2) - i32.const 255 - i32.and - local.set $5 + i32.store + local.get $3 + i32.const 1073741820 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $3 + i32.const 39 + call $~lib/rt/itcms/__new + local.tee $3 i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $1 - block $__inlined_func$assembly/codec/decodeVarU32$1 (result i32) - local.get $5 - i32.eqz - if - local.get $1 - i32.const 1 - call $assembly/codec/ValOffset#constructor - br $__inlined_func$assembly/codec/decodeVarU32$1 - end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + loop $for-loop|0 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $0 i32.store - local.get $4 + local.get $0 call $~lib/typedarray/Uint8Array#get:length - local.get $5 - i32.lt_s + local.get $2 + i32.gt_s if - global.get $~lib/memory/__stack_pointer - local.get $5 - call $~lib/number/I32#toString - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - call $~lib/number/I32#toString - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 17632 - i32.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=12 - i32.const 17636 - local.get $0 i32.store - i32.const 17632 local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link + local.get $2 + call $~lib/typedarray/Uint8Array#__get + local.set $1 global.get $~lib/memory/__stack_pointer - i32.const 17632 + global.get $assembly/instructions/INSTRUCTIONS + local.tee $4 i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - i32.const 17644 + local.get $4 + call $~lib/array/Array#get:length local.get $1 + i32.gt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $4 + i32.store + local.get $4 + local.get $1 + call $~lib/array/Array#__get + else + global.get $assembly/instructions/MISSING_INSTRUCTION + end + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store - i32.const 17632 - local.get $1 + local.get $3 + local.get $2 i32.const 1 - call $~lib/rt/itcms/__link + call $~lib/staticarray/StaticArray#__set global.get $~lib/memory/__stack_pointer - i32.const 17632 + i32.const 1264 i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=12 - i32.const 17632 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 17408 - i32.const 108 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.const 1 - i32.const 8 - local.get $5 - i32.sub - local.tee $1 - i32.shl - i32.const 0 - local.get $1 - i32.const 32 - i32.lt_u - select - i32.add - i32.const 256 - i32.sub - local.get $5 - i32.const 3 - i32.shl - i32.shl - local.set $6 - local.get $5 - i32.const 1 - i32.sub - local.set $1 - loop $for-loop|0 + i32.const 1264 local.get $1 - i32.const 0 + i32.load offset=4 + call $~lib/array/Array#__get + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $4 + local.get $2 + i32.const 1 + i32.add + local.tee $4 + i32.add i32.ge_s - if + if (result i32) + local.get $1 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + i32.const 1 + global.set $~argumentsLength + local.get $0 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store local.get $4 - local.get $1 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get + call $assembly/program-build/skipBytes local.get $2 - i32.const 8 - i32.shl i32.add - local.set $2 - local.get $1 - i32.const 1 - i32.sub - local.set $1 - br $for-loop|0 + else + local.get $2 end + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 end - local.get $2 - local.get $6 - i32.add - local.get $5 - i32.const 1 - i32.add - call $assembly/codec/ValOffset#constructor end - local.set $1 global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 18048 + call $~lib/rt/__newArray + local.tee $4 i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $2 - local.get $1 - i32.load offset=4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load + i32.const 0 + local.set $0 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $0 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + i32.lt_s + if + i32.const 0 + local.set $2 + local.get $0 + local.set $1 + loop $for-loop|3 + local.get $1 + local.get $0 + i32.const 8 + i32.add + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $2 + i32.const 255 + i32.and + i32.const 1 + i32.shr_u + local.tee $2 + i32.const 128 + i32.or + local.get $2 + local.get $1 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + i32.lt_s + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $1 + call $~lib/staticarray/StaticArray#__get + else + i32.const 0 + end + select + local.set $2 + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|3 + end + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $2 + call $~lib/array/Array#push + local.get $0 + i32.const 8 + i32.add + local.set $0 + br $for-loop|1 + end + end global.get $~lib/memory/__stack_pointer i32.const 16 i32.add global.set $~lib/memory/__stack_pointer + local.get $4 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $assembly/codec/Decoder#bytes (param $0 i32) (param $1 i32) (result i32) + (func $assembly/codec/encodeVarU32 (param $0 i64) (result i32) + (local $1 i32) (local $2 i32) (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i64) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/string/String#concat (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - local.tee $3 - local.get $2 - i32.add - local.tee $4 - i32.eqz - if + block $folding-inner2 + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner2 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + local.get $0 + i64.eqz + if + i32.const 1 + call $~lib/typedarray/Uint8Array#constructor + local.set $3 + br $folding-inner1 + end + local.get $0 + i64.const 72057594037927936 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + i32.const 9 + call $~lib/typedarray/Uint8Array#constructor + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 255 + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load + local.tee $3 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + block $__inlined_func$~lib/dataview/DataView#constructor@varargs$9 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + local.set $5 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 40 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store + local.get $1 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 20 + i32.sub + i32.load offset=16 + local.get $5 + i32.lt_u + local.get $5 + i32.const 1073741820 + i32.gt_u + i32.or + if + i32.const 9200 + i32.const 18080 + i32.const 25 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=8 + local.get $1 + local.get $3 + i32.store + local.get $1 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + br $__inlined_func$~lib/dataview/DataView#constructor@varargs$9 + end + br $folding-inner2 + end + local.tee $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner2 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load offset=8 + i32.const 9 + i32.lt_s + if + i32.const 1504 + i32.const 18080 + i32.const 174 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.load offset=4 + local.get $0 + i64.store offset=1 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + i64.const 562949953421312 + local.set $4 + i32.const 7 + local.set $1 + loop $for-loop|0 + local.get $1 + i32.const 0 + i32.ge_s + if + local.get $0 + local.get $4 + i64.ge_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $3 + i32.store offset=16 + i32.const 256 + i32.const 1 + i32.const 8 + local.get $1 + i32.sub + local.tee $2 + i32.shl + i32.const 0 + local.get $2 + i32.const 32 + i32.lt_u + select + i32.sub + i64.extend_i32_s + local.get $0 + i32.const 1 + local.get $1 + i32.const 3 + i32.shl + local.tee $2 + i32.shl + i32.const 0 + local.get $2 + i32.const 32 + i32.lt_u + select + i64.extend_i32_s + local.tee $4 + i64.div_u + i64.add + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + local.get $6 + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $0 + local.get $4 + i64.rem_u + local.set $0 + i32.const 1 + local.set $2 + loop $for-loop|1 + local.get $2 + local.get $1 + i32.const 1 + i32.add + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + local.get $2 + local.get $0 + i32.wrap_i64 + i32.const 255 + i32.and + call $~lib/typedarray/Uint8Array#__set + local.get $0 + i64.const 8 + i64.shr_u + local.set $0 + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|1 + end + end + br $folding-inner1 + end + local.get $4 + i64.const 7 + i64.shr_u + local.set $4 + local.get $1 + i32.const 1 + i32.sub + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 18144 + i32.store offset=4 + local.get $0 + i32.const 10 + call $~lib/util/number/utoa64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + i32.const 18144 + local.get $1 + call $~lib/string/String#concat + i32.const 18224 + i32.const 160 + i32.const 3 + call $~lib/builtins/abort + unreachable + end global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer - i32.const 15424 + local.get $3 return end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $4 - i32.store offset=4 - local.get $4 - local.get $0 - local.get $2 - memory.copy - local.get $2 - local.get $4 - i32.add - local.get $1 - local.get $3 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/string/String.__concat (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - call $~lib/string/String#concat - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable ) - (func $assembly/index/disassemble~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) + (func $assembly/program/liftBytes (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer local.get $0 i32.store - local.get $1 - i32.const 255 - i32.and - i32.const 16 - call $~lib/util/number/utoa32 - local.set $1 global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 + local.get $0 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $1 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 15824 - i32.store offset=12 + local.get $1 + i32.store global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer i64.const 0 i64.store global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $1 i32.store - local.get $1 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 15824 - i32.store - block $__inlined_func$~lib/string/String#padStart$2455 - i32.const 15820 - i32.load - i32.const -2 - i32.and - local.tee $2 - i32.eqz - local.get $5 - i32.const 4 - i32.gt_u - i32.or - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#padStart$2455 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store offset=4 - i32.const 4 - local.get $5 - i32.sub - local.tee $4 - local.get $2 - i32.gt_u - if - local.get $4 - local.get $4 - i32.const 2 - i32.sub - local.get $2 - i32.div_u - local.get $2 - i32.mul - local.tee $7 - i32.sub - local.set $8 - loop $while-continue|0 - local.get $6 - local.get $7 - i32.lt_u - if - local.get $3 - local.get $6 - i32.add - i32.const 15824 - local.get $2 - memory.copy - local.get $2 - local.get $6 - i32.add - local.set $6 - br $while-continue|0 - end - end - local.get $3 - local.get $7 - i32.add - i32.const 15824 - local.get $8 - memory.copy - else - local.get $3 - i32.const 15824 - local.get $4 - memory.copy - end - local.get $3 - local.get $4 - i32.add - local.get $1 - local.get $5 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - local.set $1 + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + call $~lib/array/Array#get:length + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.lt_s + if + i32.const 1504 + i32.const 1744 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable end global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 - local.get $0 + i32.store offset=8 local.get $1 - call $~lib/string/String.__concat + i32.load offset=4 global.get $~lib/memory/__stack_pointer - i32.const 16 + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=4 + local.get $2 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer + local.get $1 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $assembly/codec/Decoder#u8 (param $0 i32) (result i32) + (func $assembly/codec/Decoder#constructor (param $0 i32) (result i32) (local $1 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -24071,157 +25300,52 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load + i32.const 8 + i32.const 42 + call $~lib/rt/itcms/__new local.tee $1 i32.store global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 local.get $1 - local.get $0 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=4 - i32.const 1 - i32.add i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer local.get $0 - i32.store + i32.store offset=8 local.get $1 local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 i32.store - local.get $0 local.get $1 - i32.const 2 - i32.shl - i32.add - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer + local.get $0 i32.const 0 - i32.store + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $0 + i32.store offset=4 local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load + i32.const 0 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer + local.get $1 ) - (func $assembly/program/Mask#isInstruction (param $0 i32) (param $1 i32) (result i32) + (func $assembly/codec/Decoder#ensureBytes (param $0 i32) (param $1 i32) (local $2 i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -24231,235 +25355,158 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 + i64.const 0 + i64.store offset=8 global.get $~lib/memory/__stack_pointer local.get $0 - i32.load - local.tee $2 i32.store - local.get $2 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i64.extend_i32_s local.get $1 - i64.extend_i32_u - i64.le_u - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - i32.eqz - global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.load offset=4 i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/Mask#skipBytesToNextInstruction (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + local.set $2 global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 i32.load - local.tee $2 + local.tee $3 i32.store - local.get $1 - i32.const 1 - i32.add - local.tee $1 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length local.get $2 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.lt_u + i32.lt_s if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $1 + i32.store offset=8 global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 i32.load - local.tee $0 + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + call $~lib/typedarray/Uint8Array#get:length + global.get $~lib/memory/__stack_pointer + local.get $0 i32.store local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get + i32.load offset=4 + i32.sub + call $~lib/number/I32#toString + local.tee $0 + i32.store offset=12 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 + i32.const 18416 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 18420 + local.get $1 + i32.store + i32.const 18416 + local.get $1 i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 18428 + local.get $0 + i32.store + i32.const 18416 + local.get $0 i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 18416 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store offset=4 + i32.const 18416 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 18224 + i32.const 25 + i32.const 7 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $0 - i32.eqz - if - i32.const 17824 - i32.const 9152 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $0 ) - (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) + (func $assembly/codec/ValOffset#constructor (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i32.const 0 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 43 + call $~lib/rt/itcms/__new + local.tee $2 i32.store global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 local.get $0 i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load + i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer + local.get $2 ) - (func $assembly/program/BasicBlocks#constructor (param $0 i32) (param $1 i32) (result i32) + (func $assembly/codec/Decoder#varU32 (param $0 i32) (result i32) + (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) - (local $7 i32) - (local $8 i32) global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -24469,219 +25516,333 @@ i64.const 0 i64.store offset=8 global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 34 - call $~lib/rt/itcms/__new - local.tee $4 + local.get $0 i32.store + local.get $0 + i32.const 1 + call $assembly/codec/Decoder#ensureBytes global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store - local.get $4 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $1 i32.store offset=4 + global.get $~lib/memory/__stack_pointer local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $5 + i32.store offset=8 + local.get $0 + i32.load offset=4 + local.set $4 + i32.const 1 + global.set $~argumentsLength + local.get $1 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $4 global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $5 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - local.get $5 - i32.const 2 - i32.shl - i32.const 35 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store + i64.const 0 + i64.store offset=8 global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 + local.get $4 + i32.store + local.get $4 + i32.const 0 + call $~lib/typedarray/Uint8Array#__get + i32.const 1 + global.set $~argumentsLength + i32.const 15392 + i32.load + call_indirect (type $2) + i32.const 255 + i32.and + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 + local.get $4 + i32.store + local.get $4 i32.const 0 - i32.const 2 - call $~lib/staticarray/StaticArray#__set - loop $for-loop|0 - local.get $3 + call $~lib/typedarray/Uint8Array#__get + local.set $1 + block $__inlined_func$assembly/codec/decodeVarU32$1 (result i32) + local.get $5 + i32.eqz + if + local.get $1 + i32.const 1 + call $assembly/codec/ValOffset#constructor + br $__inlined_func$assembly/codec/decodeVarU32$1 + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $~lib/typedarray/Uint8Array#get:length local.get $5 i32.lt_s if global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $5 + call $~lib/number/I32#toString + local.tee $0 i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + call $~lib/typedarray/Uint8Array#get:length + call $~lib/number/I32#toString + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 18624 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + i32.const 18628 + local.get $0 + i32.store + i32.const 18624 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 18624 + i32.store + global.get $~lib/memory/__stack_pointer local.get $1 - local.get $3 - call $assembly/program/Mask#isInstruction + i32.store offset=12 + i32.const 18636 + local.get $1 + i32.store + i32.const 18624 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 18624 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store offset=12 + i32.const 18624 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 18224 + i32.const 108 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.const 1 + i32.const 8 + local.get $5 + i32.sub + local.tee $1 + i32.shl + i32.const 0 + local.get $1 + i32.const 32 + i32.lt_u + select + i32.add + i32.const 256 + i32.sub + local.get $5 + i32.const 3 + i32.shl + i32.shl + local.set $6 + local.get $5 + i32.const 1 + i32.sub + local.set $1 + loop $for-loop|0 + local.get $1 + i32.const 0 + i32.ge_s if global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 local.get $1 - i32.store offset=4 - local.get $1 - local.get $3 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $3 + i32.const 1 + i32.add call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $6 - i32.store offset=4 - local.get $6 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $6 - local.get $0 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#__get - end - i32.load8_u offset=16 - if - local.get $5 - local.get $3 - i32.const 1 - i32.add - local.get $7 - i32.add - local.tee $6 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $6 - i32.const 2 - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - local.get $3 - local.get $2 - local.get $3 - call $~lib/staticarray/StaticArray#__get - i32.const 4 - i32.or - call $~lib/staticarray/StaticArray#__set - end + local.get $2 + i32.const 8 + i32.shl + i32.add + local.set $2 + local.get $1 + i32.const 1 + i32.sub + local.set $1 + br $for-loop|0 end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 end + local.get $2 + local.get $6 + i32.add + local.get $5 + i32.const 1 + i32.add + call $assembly/codec/ValOffset#constructor end + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $4 + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $2 global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 local.get $2 - i32.store offset=12 - local.get $4 - local.get $2 + local.get $1 + i32.load offset=4 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 i32.store - local.get $4 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link + local.get $1 + i32.load global.get $~lib/memory/__stack_pointer i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $assembly/program/deblob (param $0 i32) (result i32) + (func $assembly/codec/Decoder#bytes (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $3 + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $1 + local.get $0 + i32.load offset=4 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + ) + (func $assembly/program/extractCodeAndMetadata (param $0 i32) (result i32) (local $1 i32) (local $2 i32) (local $3 i32) - (local $4 i64) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i64) - (local $10 i64) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $14 i32) - (local $15 i32) - (local $16 i32) + (local $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 44 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner1 + block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner1 + br_if $folding-inner0 global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 44 + i32.const 20 memory.fill global.get $~lib/memory/__stack_pointer local.get $0 @@ -24700,466 +25861,125 @@ global.get $~lib/memory/__stack_pointer local.get $0 i32.store + global.get $~lib/memory/__stack_pointer local.get $0 - call $assembly/codec/Decoder#u8 - local.set $5 + local.get $1 + call $assembly/codec/Decoder#bytes + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer local.get $0 i32.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $0 - call $assembly/codec/Decoder#varU32 - local.set $11 + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 + i32.load + local.tee $3 i32.store global.get $~lib/memory/__stack_pointer local.get $0 - local.get $1 - local.get $5 - i32.mul - call $assembly/codec/Decoder#bytes - local.tee $14 + i32.store offset=4 + local.get $0 + i32.load offset=4 + local.set $4 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $3 i32.store offset=8 global.get $~lib/memory/__stack_pointer local.get $0 i32.store global.get $~lib/memory/__stack_pointer local.get $0 - local.get $11 - call $assembly/codec/Decoder#bytes - local.tee $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer + i32.store offset=4 local.get $0 - i32.store + i32.load offset=4 + local.set $4 global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 local.get $0 - local.get $11 - i32.const 7 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + local.get $4 i32.add - i32.const 3 - i32.shr_u - call $assembly/codec/Decoder#bytes - local.tee $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 i32.store offset=16 global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - global.get $~lib/memory/__stack_pointer - block $__inlined_func$assembly/program/Mask#constructor$11 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 31 - call $~lib/rt/itcms/__new - local.tee $13 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=4 - local.get $13 - i32.const 0 - i32.store - local.get $13 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $11 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.const 2 - i32.shl - i32.const 32 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $13 - local.get $0 - i32.store - local.get $13 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.sub - local.set $1 - loop $for-loop|0 - local.get $1 - i32.const 0 - i32.ge_s - if - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $1 - call $~lib/typedarray/Uint8Array#__get - local.set $0 - local.get $1 - i32.const 3 - i32.shl - local.set $15 - i32.const 7 - local.set $2 - loop $for-loop|2 - local.get $2 - i32.const 0 - i32.ge_s - if - local.get $0 - i32.const 128 - i32.and - local.set $16 - local.get $0 - i32.const 1 - i32.shl - local.set $0 - local.get $2 - local.get $15 - i32.add - local.tee $7 - local.get $11 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.load - local.tee $8 - i32.store offset=4 - local.get $8 - local.get $7 - i32.const 25 - i32.const 0 - local.get $6 - i32.const 1 - i32.add - local.get $16 - select - local.tee $6 - local.get $6 - i32.const 25 - i32.ge_u - select - call $~lib/staticarray/StaticArray#__set - end - local.get $2 - i32.const 1 - i32.sub - local.set $2 - br $for-loop|2 - end - end - local.get $1 - i32.const 1 - i32.sub - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - br $__inlined_func$assembly/program/Mask#constructor$11 - end - br $folding-inner1 - end - local.tee $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 33 - call $~lib/rt/itcms/__new - local.tee $7 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - i32.const 0 - i32.store - local.get $7 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.const 255 - i32.and - local.tee $1 - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.div_s - else - i32.const 0 - end - call $~lib/staticarray/StaticArray#constructor - local.tee $8 - i32.store offset=8 - i32.const 0 - local.set $1 - loop $for-loop|01 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.gt_s - if - i64.const 0 - local.set $4 - local.get $5 - i32.const 1 - i32.sub - i32.const 255 - i32.and - local.set $2 - loop $for-loop|1 - local.get $2 - i32.const 0 - i32.ge_s - if - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - i64.const -1 - local.get $4 - i64.const 8 - i64.shl - local.tee $9 - local.get $14 - local.get $1 - local.get $2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i64.extend_i32_u - i64.add - local.tee $10 - local.get $4 - local.get $10 - i64.gt_u - local.get $4 - local.get $9 - i64.gt_u - i32.or - select - local.set $4 - local.get $2 - i32.const 1 - i32.sub - local.set $2 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $1 - local.get $5 - i32.const 255 - i32.and - local.tee $2 - i32.div_s - local.get $4 - call $~lib/staticarray/StaticArray#__set - local.get $1 - local.get $2 - i32.add - local.set $1 - br $for-loop|01 - end - end - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $7 - local.get $8 - i32.store - local.get $7 - local.get $8 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $0 - call $assembly/program/BasicBlocks#constructor - local.tee $1 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 41 + call $~lib/rt/itcms/__new + local.tee $0 i32.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 30 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $3 i32.store offset=8 - local.get $2 + local.get $0 local.get $3 i32.store - local.get $2 + local.get $0 local.get $3 i32.const 0 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $2 - local.get $0 - i32.store offset=4 - local.get $2 local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $2 - local.get $7 - i32.store offset=8 - local.get $2 - local.get $7 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=8 - local.get $2 + local.get $0 local.get $1 - i32.store offset=12 - local.get $2 + i32.store offset=4 + local.get $0 local.get $1 i32.const 0 call $~lib/rt/itcms/__link @@ -25168,144 +25988,131 @@ i32.add global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 44 + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $0 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) + (func $assembly/codec/Decoder#u24 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store - local.get $1 local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end + i32.const 3 + call $assembly/codec/Decoder#ensureBytes + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 + i32.load + local.tee $1 i32.store + global.get $~lib/memory/__stack_pointer local.get $0 - i32.load offset=4 + i32.store offset=4 local.get $1 - i32.const 2 - i32.shl - i32.add + local.get $0 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 i32.load + local.tee $2 + i32.store global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 1 i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer + call $~lib/typedarray/Uint8Array#__get i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end + i32.shl + i32.or global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + local.get $0 + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 + i32.load + local.tee $2 i32.store - local.get $1 + global.get $~lib/memory/__stack_pointer local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=4 + i32.const 2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 16 + i32.shl + i32.or global.get $~lib/memory/__stack_pointer local.get $0 i32.store global.get $~lib/memory/__stack_pointer local.get $0 + i32.store offset=4 + local.get $0 + local.get $0 i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl + i32.const 3 i32.add - i32.load - local.tee $0 i32.store offset=4 - local.get $0 - i32.eqz - if - i32.const 17824 - i32.const 9152 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $0 ) - (func $assembly/program/decodeArguments (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) + (func $assembly/codec/Decoder#u32 (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -25315,180 +26122,11 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 1264 + local.get $0 i32.store - i32.const 1264 local.get $0 - call $~lib/array/Array#__get - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 1264 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 1264 - local.get $0 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#constructor - local.tee $4 - i32.store offset=4 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $3 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $4 - local.get $3 - local.get $1 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - i32.const 2 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 2272 - i32.store offset=8 - local.get $4 - local.get $2 - i32.const 2272 - local.get $0 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $1) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 2 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 2272 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 2272 - local.get $0 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $1) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - global.get $~lib/memory/__stack_pointer i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-generic/getAssembly (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill + call $assembly/codec/Decoder#ensureBytes global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 @@ -25497,381 +26135,33 @@ i32.load local.tee $1 i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $4 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 17952 - return - end - i32.const 15424 - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - loop $for-loop|0 - local.get $3 - local.get $4 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - local.get $2 - local.get $3 - call $assembly/program/Mask#isInstruction - i32.eqz - if - i32.const 18032 - i32.const 18144 - i32.const 46 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - local.set $2 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $5 - i32.store - local.get $2 - local.get $5 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $5 - i32.store - local.get $5 - local.get $2 - call $~lib/array/Array#__get - end - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 18224 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 18224 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - call $~lib/number/I32#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 18256 - i32.store offset=16 - local.get $7 - i32.const 18256 - call $~lib/string/String#concat - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $1 - local.get $7 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $6 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.const 255 - i32.and - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $2 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 18352 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - i32.const 18356 - local.get $2 - i32.store - i32.const 18352 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 18352 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=16 - i32.const 18352 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - local.get $2 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - local.get $2 - local.get $3 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $8 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - local.get $8 - local.get $3 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $6 - call $assembly/program/decodeArguments - local.tee $2 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - i32.const 42 - i32.const 0 - call $~lib/rt/__newArray - local.tee $8 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 0 - local.get $2 - i32.load - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 1 - local.get $2 - i32.load offset=4 - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 2 - local.get $2 - i32.load offset=8 - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 3 - local.get $2 - i32.load offset=12 - call $~lib/array/Array#__set - local.get $8 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 1136 - i32.store - i32.const 1136 - local.get $5 - i32.load offset=4 - call $~lib/array/Array#__get - local.set $5 - i32.const 0 - local.set $2 - loop $for-loop|1 - local.get $2 - local.get $5 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $8 - local.get $2 - call $~lib/array/Array#__get - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $9 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - i32.const 18448 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - i32.const 18452 - local.get $9 - i32.store - i32.const 18448 - local.get $9 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 18448 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=16 - i32.const 18448 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $1 - local.get $9 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end - end - local.get $3 - local.get $6 - i32.add - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/codec/Decoder#u24 (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store + i32.store offset=4 + local.get $1 local.get $0 - i32.const 3 - call $assembly/codec/Decoder#ensureBytes + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 i32.load - local.tee $1 + local.tee $2 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $1 + local.get $2 local.get $0 i32.load offset=4 + i32.const 1 + i32.add call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 @@ -25886,10 +26176,10 @@ local.get $2 local.get $0 i32.load offset=4 - i32.const 1 + i32.const 2 i32.add call $~lib/typedarray/Uint8Array#__get - i32.const 8 + i32.const 16 i32.shl i32.or global.get $~lib/memory/__stack_pointer @@ -25906,10 +26196,10 @@ local.get $2 local.get $0 i32.load offset=4 - i32.const 2 + i32.const 3 i32.add call $~lib/typedarray/Uint8Array#__get - i32.const 16 + i32.const 24 i32.shl i32.or global.get $~lib/memory/__stack_pointer @@ -25921,7 +26211,7 @@ local.get $0 local.get $0 i32.load offset=4 - i32.const 3 + i32.const 4 i32.add i32.store offset=4 global.get $~lib/memory/__stack_pointer @@ -25929,19 +26219,18 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/codec/Decoder#u32 (param $0 i32) (result i32) + (func $assembly/codec/Decoder#isExhausted (param $0 i32) (result i32) (local $1 i32) - (local $2 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -25954,83 +26243,66 @@ local.get $0 i32.store local.get $0 - i32.const 4 - call $assembly/codec/Decoder#ensureBytes + i32.load offset=4 + local.set $1 global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 i32.load - local.tee $1 + local.tee $0 i32.store - global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + call $~lib/typedarray/Uint8Array#get:length local.get $1 - local.get $0 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store + i32.le_s global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 1 + i32.const 8 i32.add - call $~lib/typedarray/Uint8Array#__get + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/codec/Decoder#u8 (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer i32.const 8 - i32.shl - i32.or + i32.sub + global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 - local.get $2 + i32.store local.get $0 - i32.load offset=4 - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or + i32.const 1 + call $assembly/codec/Decoder#ensureBytes global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 i32.load - local.tee $2 + local.tee $1 i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 - local.get $2 + local.get $1 local.get $0 i32.load offset=4 - i32.const 3 - i32.add call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or global.get $~lib/memory/__stack_pointer local.get $0 i32.store @@ -26040,7 +26312,7 @@ local.get $0 local.get $0 i32.load offset=4 - i32.const 4 + i32.const 1 i32.add i32.store offset=4 global.get $~lib/memory/__stack_pointer @@ -26048,702 +26320,598 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/codec/Decoder#isExhausted (param $0 i32) (result i32) - (local $1 i32) + (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + i32.const 0 + i32.store global.get $~lib/memory/__stack_pointer local.get $0 i32.store + local.get $1 local.get $0 - i32.load offset=4 - local.set $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 93 + i32.const 41 + call $~lib/builtins/abort + unreachable + end global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + i32.store + local.get $0 + local.get $1 + i32.const 2 + i32.shl + i32.add + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.load - local.tee $0 i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.ge_u + if + i32.const 1504 + i32.const 9312 + i32.const 78 + i32.const 41 + call $~lib/builtins/abort + unreachable + end local.get $0 - call $~lib/typedarray/Uint8Array#get:length local.get $1 - i32.le_s + i32.const 2 + i32.shl + i32.add + i32.load global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/program/decodeSpi (param $0 i32) (result i32) - (local $1 i32) + (func $assembly/program/BasicBlocks#constructor (param $0 i32) (param $1 i32) (result i32) (local $2 i32) (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - local.get $0 + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.const 34 + call $~lib/rt/itcms/__new + local.tee $4 i32.store global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/codec/Decoder#constructor - local.tee $1 + local.get $4 i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $4 + i32.const 0 i32.store - local.get $1 - call $assembly/codec/Decoder#u24 - local.set $2 + local.get $4 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#u24 - local.set $0 + local.get $0 + i32.store offset=4 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 + i32.const 0 i32.store - local.get $1 - i32.const 2 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 + local.get $5 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $3 + local.get $5 + i32.const 2 + i32.shl + i32.const 35 + call $~lib/rt/itcms/__new + local.tee $2 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $3 - local.get $1 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - drop + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $5 + i32.const 0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.const 2 + call $~lib/staticarray/StaticArray#__set + end + loop $for-loop|0 + local.get $3 + local.get $5 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $3 + call $assembly/program/Mask#isInstruction + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $3 + call $assembly/program/Mask#skipBytesToNextInstruction + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $6 + i32.store offset=4 + local.get $6 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $6 + local.get $0 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#__get + end + i32.load8_u offset=16 + if + local.get $5 + local.get $3 + i32.const 1 + i32.add + local.get $7 + i32.add + local.tee $6 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $6 + i32.const 2 + call $~lib/staticarray/StaticArray#__set + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + local.get $3 + local.get $2 + local.get $3 + call $~lib/staticarray/StaticArray#__get + i32.const 4 + i32.or + call $~lib/staticarray/StaticArray#__set + end + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $4 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $3 + local.get $2 + i32.store offset=12 + local.get $4 + local.get $2 i32.store + local.get $4 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $3 - local.get $1 - i32.load offset=4 - i32.const 1 + i32.const 16 i32.add - call $~lib/typedarray/Uint8Array#__get - drop + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/program/deblob (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i64) + (local $10 i64) + (local $11 i32) + (local $12 i32) + (local $13 i32) + (local $14 i32) + (local $15 i32) + (local $16 i32) + global.get $~lib/memory/__stack_pointer + i32.const 44 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 global.get $~lib/memory/__stack_pointer - local.get $1 + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 44 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $1 - i32.load offset=4 - i32.const 2 - i32.add + local.get $0 + call $assembly/codec/Decoder#constructor + local.tee $0 i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/codec/Decoder#varU32 + local.set $1 global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $0 i32.store - local.get $1 - call $assembly/codec/Decoder#u24 - drop + local.get $0 + call $assembly/codec/Decoder#u8 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $0 + i32.store + local.get $0 + call $assembly/codec/Decoder#varU32 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $0 i32.store global.get $~lib/memory/__stack_pointer + local.get $0 local.get $1 - local.get $2 + local.get $5 + i32.mul call $assembly/codec/Decoder#bytes + local.tee $14 i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $0 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 local.get $0 + local.get $11 call $assembly/codec/Decoder#bytes + local.tee $3 i32.store offset=12 global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#u32 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $0 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 local.get $0 + local.get $11 + i32.const 7 + i32.add + i32.const 3 + i32.shr_u call $assembly/codec/Decoder#bytes - local.tee $0 + local.tee $12 i32.store offset=16 global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $12 i32.store global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 18480 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $0 - i32.store offset=8 - local.get $0 - call $~lib/typedarray/Uint8Array#get:length + block $__inlined_func$assembly/program/Mask#constructor$17 (result i32) global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - i32.load offset=4 + i32.const 12 i32.sub - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 18480 - local.get $0 - call $~lib/string/String#concat - i32.const 17408 - i32.const 31 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/program/deblob - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner2 - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner2 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/program/liftBytes - local.tee $3 - i32.store offset=4 - i32.const 15424 - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - local.get $2 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - block $__inlined_func$assembly/program/extractCodeAndMetadata$14 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - call $assembly/codec/Decoder#constructor - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/Decoder#varU32 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - call $assembly/codec/Decoder#bytes - local.tee $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.load offset=4 - local.set $7 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $6 - local.get $7 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.load offset=4 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $2 - local.get $6 - call $~lib/typedarray/Uint8Array#get:length - local.get $7 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 37 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $2 - local.get $6 - i32.store - local.get $2 - local.get $6 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $2 - local.get $3 - i32.store offset=4 - local.get $2 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - br $__inlined_func$assembly/program/extractCodeAndMetadata$14 - end - br $folding-inner2 - end - local.tee $2 - i32.store offset=12 + global.set $~lib/memory/__stack_pointer + block $folding-inner00 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store + i32.const 21764 + i32.lt_s + br_if $folding-inner00 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $3 - i32.store offset=4 + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer - i32.const 17680 + i32.const 0 i32.store offset=8 global.get $~lib/memory/__stack_pointer - i32.const 17680 + i32.const 4 + i32.const 31 + call $~lib/rt/itcms/__new + local.tee $13 i32.store global.get $~lib/memory/__stack_pointer - i32.const 17728 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 17680 - i32.const 17728 - call $~lib/string/String.__concat - local.tee $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $13 + i32.store offset=4 + local.get $13 + i32.const 0 i32.store + local.get $13 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - local.tee $8 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 17760 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner2 + br_if $folding-inner00 global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 20 - memory.fill + i32.store + local.get $11 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end global.get $~lib/memory/__stack_pointer - local.get $8 + local.get $11 + i32.const 2 + i32.shl + i32.const 32 + call $~lib/rt/itcms/__new + local.tee $0 i32.store global.get $~lib/memory/__stack_pointer - i32.const 17760 - i32.store offset=4 + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 15424 + local.get $0 i32.store offset=8 + local.get $13 + local.get $0 + i32.store + local.get $13 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - i32.load offset=4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 + local.get $12 + i32.store offset=4 + local.get $12 call $~lib/typedarray/Uint8Array#get:length - local.set $2 + i32.const 1 + i32.sub + local.set $1 loop $for-loop|0 - local.get $2 - local.get $4 - i32.gt_s + local.get $1 + i32.const 0 + i32.ge_s if global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $4 - local.get $9 - i32.add - i32.load8_u - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - i32.const 4 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $5 - local.get $4 - local.get $8 - i32.const 17760 - i32.load - call_indirect (type $7) - local.tee $0 - i32.store offset=8 - local.get $4 + local.get $12 + i32.store offset=4 + local.get $12 + local.get $1 + call $~lib/typedarray/Uint8Array#__get + local.set $0 + local.get $1 + i32.const 3 + i32.shl + local.set $15 + i32.const 7 + local.set $2 + loop $for-loop|2 + local.get $2 + i32.const 0 + i32.ge_s + if + local.get $0 + i32.const 128 + i32.and + local.set $16 + local.get $0 + i32.const 1 + i32.shl + local.set $0 + local.get $2 + local.get $15 + i32.add + local.tee $7 + local.get $11 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.load + local.tee $8 + i32.store offset=4 + local.get $8 + local.get $7 + i32.const 25 + i32.const 0 + local.get $6 + i32.const 1 + i32.add + local.get $16 + select + local.tee $6 + local.get $6 + i32.const 25 + i32.ge_u + select + call $~lib/staticarray/StaticArray#__set + end + local.get $2 + i32.const 1 + i32.sub + local.set $2 + br $for-loop|2 + end + end + local.get $1 i32.const 1 - i32.add - local.set $4 + i32.sub + local.set $1 br $for-loop|0 end end global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - local.get $6 - local.get $0 - call $~lib/string/String.__concat - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 17792 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 17792 - call $~lib/string/String.__concat - local.tee $0 - i32.store offset=8 - end - local.get $1 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - call $assembly/program/deblob - local.tee $1 - i32.store offset=36 - br $folding-inner1 - end - local.get $1 - i32.const 1 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - call $assembly/program/decodeSpi - local.tee $1 - i32.store offset=40 - br $folding-inner1 + local.get $13 + br $__inlined_func$assembly/program/Mask#constructor$17 end - global.get $~lib/memory/__stack_pointer - i32.const 18608 - i32.store - local.get $1 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - i32.const 18608 - local.get $0 - call $~lib/string/String#concat - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - return + br $folding-inner1 end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 + local.tee $0 i32.store offset=20 - local.get $1 - call $assembly/api-generic/getAssembly - local.set $1 global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - local.get $0 - local.get $1 - call $~lib/string/String.__concat global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add + local.get $14 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-generic/VmInput#constructor (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -26753,85 +26921,200 @@ i64.const 0 i64.store offset=8 global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 47 + i32.const 4 + i32.const 33 call $~lib/rt/itcms/__new - local.tee $0 + local.tee $7 i32.store global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $7 + i32.store offset=4 + local.get $7 + i32.const 0 + i32.store + local.get $7 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.const 255 + i32.and + local.tee $1 + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.div_s + else + i32.const 0 + end + call $~lib/staticarray/StaticArray#constructor + local.tee $8 + i32.store offset=8 + i32.const 0 + local.set $1 + loop $for-loop|01 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + local.get $14 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.gt_s + if + i64.const 0 + local.set $4 + local.get $5 + i32.const 1 + i32.sub + i32.const 255 + i32.and + local.set $2 + loop $for-loop|1 + local.get $2 + i32.const 0 + i32.ge_s + if + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store offset=4 + i64.const -1 + local.get $4 + i64.const 8 + i64.shl + local.tee $9 + local.get $14 + local.get $1 + local.get $2 + i32.add + call $~lib/typedarray/Uint8Array#__get + i64.extend_i32_u + i64.add + local.tee $10 + local.get $4 + local.get $10 + i64.gt_u + local.get $4 + local.get $9 + i64.gt_u + i32.or + select + local.set $4 + local.get $2 + i32.const 1 + i32.sub + local.set $2 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $1 + local.get $5 + i32.const 255 + i32.and + local.tee $2 + i32.div_s + local.get $4 + call $~lib/staticarray/StaticArray#__set + local.get $1 + local.get $2 + i32.add + local.set $1 + br $for-loop|01 + end + end + global.get $~lib/memory/__stack_pointer + local.get $7 i32.store offset=4 global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + local.get $7 + local.get $8 + i32.store + local.get $7 + local.get $8 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer local.get $0 - call $~lib/object/Object#constructor + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $0 + call $assembly/program/BasicBlocks#constructor local.tee $1 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 + i32.store offset=40 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer i32.const 16 - i32.const 43 + i32.const 30 call $~lib/rt/itcms/__new local.tee $2 i32.store global.get $~lib/memory/__stack_pointer local.get $2 i32.store offset=4 - local.get $2 - i32.const 0 - i32.store - local.get $2 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 + local.get $3 i32.store offset=8 - global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=4 + local.get $3 + i32.store local.get $2 + local.get $3 i32.const 0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 104 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store offset=8 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer local.get $2 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=12 + i32.store offset=8 local.get $2 local.get $0 - i32.store + i32.store offset=4 local.get $2 local.get $0 i32.const 0 @@ -26839,194 +27122,42 @@ global.get $~lib/memory/__stack_pointer local.get $2 i32.store offset=4 - local.get $2 - local.get $0 - i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 104 + local.get $7 i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 13 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=12 - i32.const 1 - global.set $~argumentsLength - block $__inlined_func$~lib/array/Array#fill@varargs$16 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load offset=12 - local.tee $4 - i32.const 0 - local.get $4 - i32.const 0 - i32.le_s - select - local.tee $0 - local.get $4 - local.tee $4 - i32.lt_s - if - local.get $3 - local.get $0 - i32.const 3 - i32.shl - i32.add - i32.const 0 - local.get $4 - local.get $0 - i32.sub - i32.const 3 - i32.shl - memory.fill - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - br $__inlined_func$~lib/array/Array#fill@varargs$16 - end - br $folding-inner1 - end - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $7 i32.store offset=8 - local.get $1 - local.get $0 - i32.store - local.get $1 - local.get $0 + local.get $2 + local.get $7 i32.const 0 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $2 i32.store offset=4 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 18656 - call $~lib/rt/__newArray - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store offset=16 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 18688 - call $~lib/rt/__newArray - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 i32.store offset=8 + local.get $2 local.get $1 - local.get $0 - i32.store offset=20 + i32.store offset=12 + local.get $2 local.get $1 - local.get $0 i32.const 0 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 18720 - call $~lib/rt/__newArray - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store offset=24 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 44 i32.add global.set $~lib/memory/__stack_pointer - local.get $1 + local.get $2 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -27046,7 +27177,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27093,7 +27224,7 @@ i32.const 0 i32.const 2 i32.const 17 - i32.const 18752 + i32.const 19056 call $~lib/rt/__newArray local.set $2 global.get $~lib/memory/__stack_pointer @@ -27142,7 +27273,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27228,7 +27359,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27292,8 +27423,8 @@ local.get $0 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -27309,7 +27440,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27320,7 +27451,7 @@ i32.store offset=8 global.get $~lib/memory/__stack_pointer i32.const 8 - i32.const 50 + i32.const 45 call $~lib/rt/itcms/__new local.tee $0 i32.store @@ -27340,7 +27471,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27447,13 +27578,128 @@ local.get $0 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) + (func $assembly/memory/MemoryBuilder#getOrCreatePageForAddress (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $2 + i32.const 12 + i32.shr_u + local.tee $2 + i32.const 16 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + i32.const 19088 + i32.store + local.get $2 + i32.const 10 + call $~lib/util/number/utoa32 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 19088 + local.get $0 + call $~lib/string/String#concat + i32.const 19184 + i32.const 93 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store + local.get $3 + local.get $2 + call $"~lib/map/Map#has" + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + call $assembly/memory-page/Arena#acquire + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $1 + local.get $3 + call $assembly/memory-page/Page#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $4 + local.get $2 + local.get $1 + call $"~lib/map/Map#set" + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + local.get $2 + call $"~lib/map/Map#get" + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) (func $assembly/memory/MemoryBuilder#setData (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (local $4 i32) (local $5 i32) @@ -27461,17 +27707,17 @@ (local $7 i32) (local $8 i32) global.get $~lib/memory/__stack_pointer - i32.const 28 + i32.const 24 i32.sub global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 28 + i32.const 24 memory.fill global.get $~lib/memory/__stack_pointer local.get $3 @@ -27485,129 +27731,50 @@ i32.const 0 i32.gt_s if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 local.get $2 - i32.const 12 - i32.shr_u + call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + i32.const 4096 + local.get $2 + i32.const 4095 + i32.and + local.tee $7 + i32.sub local.tee $4 - i32.const 16 i32.lt_u if global.get $~lib/memory/__stack_pointer - i32.const 18784 + local.get $3 i32.store offset=4 - local.get $4 - i32.const 10 - call $~lib/util/number/utoa32 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 18784 - local.get $0 - call $~lib/string/String#concat - i32.const 18880 - i32.const 67 - i32.const 9 - call $~lib/builtins/abort - unreachable + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + local.set $4 end global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 + local.get $5 + i32.store offset=20 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load + local.get $5 + i32.load offset=4 local.tee $5 - i32.store offset=4 - local.get $5 - local.get $4 - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - call $assembly/memory-page/Arena#acquire - local.tee $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $1 - local.get $5 - call $assembly/memory-page/Page#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $6 - local.get $4 - local.get $5 - call $"~lib/map/Map#set" - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - local.get $4 - call $"~lib/map/Map#get" - local.tee $5 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - i32.const 4096 - local.get $2 - i32.const 4095 - i32.and - local.tee $7 - i32.sub - local.tee $4 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - end - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $5 - i32.store offset=16 + i32.store offset=16 local.get $5 call $assembly/memory-page/RawPage#get:data - local.set $5 + local.set $6 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $6 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $3 @@ -27616,16 +27783,16 @@ i32.const 0 local.get $4 call $~lib/typedarray/Uint8Array#subarray - local.set $6 + local.set $8 global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 + local.get $8 + i32.store offset=12 global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27635,24 +27802,24 @@ i32.const 0 i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $6 i32.store global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $8 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $8 i32.store offset=8 - local.get $6 + local.get $8 call $~lib/typedarray/Uint8Array#get:length - local.set $8 + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $6 i32.store offset=8 - local.get $5 + local.get $6 call $~lib/typedarray/Uint8Array#get:length + local.get $5 local.get $7 - local.get $8 i32.add i32.lt_s if @@ -27664,18 +27831,18 @@ unreachable end global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $6 i32.store offset=8 local.get $7 - local.get $5 + local.get $6 i32.load offset=4 i32.add global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $8 i32.store offset=8 - local.get $6 - i32.load offset=4 local.get $8 + i32.load offset=4 + local.get $5 memory.copy global.get $~lib/memory/__stack_pointer i32.const 12 @@ -27700,18 +27867,66 @@ end end global.get $~lib/memory/__stack_pointer - i32.const 28 + i32.const 24 i32.add global.set $~lib/memory/__stack_pointer return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) + (func $assembly/memory/MemoryBuilder#setEmpty (param $0 i32) (param $1 i32) (param $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $1 + local.get $2 + i32.add + local.set $2 + loop $for-loop|0 + local.get $1 + local.get $2 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 2 + local.get $1 + call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress + drop + local.get $1 + i32.const 4096 + i32.add + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) (func $assembly/memory/MemoryBuilder#build (param $0 i32) (param $1 i32) (result i32) (local $2 i32) (local $3 i32) @@ -27721,7 +27936,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27751,7 +27966,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27811,9 +28026,9 @@ i32.const 16 i32.lt_u if - i32.const 18944 - i32.const 18880 - i32.const 104 + i32.const 19248 + i32.const 19184 + i32.const 119 i32.const 7 call $~lib/builtins/abort unreachable @@ -27845,244 +28060,588 @@ local.get $0 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $assembly/api-generic/buildMemory (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $assembly/spi/StandardProgram#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) global.get $~lib/memory/__stack_pointer - i32.const 24 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 24 - memory.fill - i32.const 65536 - local.set $3 - loop $for-loop|0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.const 44 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $3 + local.get $0 + i32.store offset=16 + local.get $3 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + i32.store offset=20 + local.get $3 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $3 + local.get $2 + i32.store offset=24 + local.get $3 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $3 + local.get $0 + i32.store + local.get $3 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + ) + (func $assembly/spi/decodeSpi (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 52 + memory.fill global.get $~lib/memory/__stack_pointer local.get $1 i32.store local.get $1 - call $~lib/array/Array#get:length - local.get $4 - i32.gt_s + call $~lib/typedarray/Uint8Array#get:length + local.tee $2 + i32.const 16777216 + i32.gt_u if global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $4 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.tee $6 + local.get $2 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $0 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - i32.load offset=8 - local.set $8 + i32.const 16777216 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $1 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - i32.load - local.set $7 + i32.const 18816 + i32.store global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $0 i32.store offset=12 - local.get $6 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 + i32.const 18820 local.get $0 - local.get $8 - local.get $7 - local.get $9 - call $assembly/memory/MemoryBuilder#setData - global.get $~lib/memory/__stack_pointer - local.get $6 i32.store - local.get $6 - i32.load offset=8 - i32.const 2 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $3 - local.get $6 - i32.load - i32.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load - local.set $3 - end - end - local.get $4 + i32.const 18816 + local.get $0 i32.const 1 - i32.add - local.set $4 - br $for-loop|0 - end - end - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - local.get $5 - i32.gt_s - if + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $2 + i32.const 18816 i32.store global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.tee $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer + i32.store offset=12 + i32.const 18828 local.get $1 - i32.load offset=4 - local.tee $4 i32.store + i32.const 18816 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $4 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $6 - i32.store offset=20 - i32.const 0 - local.set $4 - loop $for-loop|2 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/typedarray/Uint8Array#get:length - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - local.get $6 - local.get $4 - local.get $7 - local.get $4 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|2 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 + i32.const 18816 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 + i32.const 15504 i32.store offset=12 - local.get $1 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $0 - i32.const 0 - local.get $1 - local.get $6 - call $assembly/memory/MemoryBuilder#setData - local.get $5 - i32.const 1 - i32.add - local.set $5 - br $for-loop|1 + i32.const 18816 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 18864 + i32.const 18 + i32.const 5 + call $~lib/builtins/abort + unreachable end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - call $assembly/memory/MemoryBuilder#build - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/interpreter/Interpreter#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $assembly/codec/Decoder#constructor + local.tee $4 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#u24 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#u24 + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 + local.get $4 + i32.store + local.get $4 + i32.const 2 + call $assembly/codec/Decoder#ensureBytes global.get $~lib/memory/__stack_pointer - i32.const 33 - i32.const 29 - call $~lib/rt/itcms/__new + local.get $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $3 + local.get $4 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#__get + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load + local.tee $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $5 + local.get $4 + i32.load offset=4 + i32.const 1 + i32.add + call $~lib/typedarray/Uint8Array#__get + i32.const 8 + i32.shl + i32.or + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $4 + i32.load offset=4 + i32.const 2 + i32.add + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#u24 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + local.get $8 + call $assembly/codec/Decoder#bytes + local.tee $3 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + local.get $0 + call $assembly/codec/Decoder#bytes + local.tee $9 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#u32 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + local.get $5 + call $assembly/codec/Decoder#bytes + local.tee $5 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 18928 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load + local.tee $0 + i32.store offset=8 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + i32.load offset=4 + i32.sub + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 18928 + local.get $0 + call $~lib/string/String#concat + i32.const 18224 + i32.const 31 + i32.const 7 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + call $assembly/program/deblob + local.tee $4 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/MemoryBuilder#constructor + local.tee $5 + i32.store offset=36 + i32.const 65535 + i32.and + i32.const 12 + i32.shl + local.tee $6 + local.get $8 + i32.const 65535 + i32.add + i32.const -65536 + i32.and + i32.const 131072 + i32.add + local.tee $10 + local.get $0 + i32.const 4095 + i32.add + i32.const -4096 + i32.and + i32.add + local.tee $11 + i32.add + local.set $12 + i32.const -16908288 + local.get $7 + i32.const 4095 + i32.add + i32.const -4096 + i32.and + local.tee $7 + i32.sub + local.set $13 + local.get $8 + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $5 + i32.const 1 + i32.const 65536 + local.get $3 + call $assembly/memory/MemoryBuilder#setData + end + local.get $2 + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + local.get $5 + i32.const 1 + i32.const -16842752 + local.get $1 + call $assembly/memory/MemoryBuilder#setData + end + local.get $0 + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + local.get $5 + i32.const 2 + local.get $10 + local.get $9 + call $assembly/memory/MemoryBuilder#setData + end + local.get $6 + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $11 + local.get $6 + call $assembly/memory/MemoryBuilder#setEmpty + end + local.get $7 + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + local.get $13 + local.get $7 + call $assembly/memory/MemoryBuilder#setEmpty + end + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + local.get $12 + call $assembly/memory/MemoryBuilder#build + local.tee $0 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + i32.const 13 + call $~lib/staticarray/StaticArray#constructor + local.tee $1 + i32.store offset=44 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 0 + i64.const 4294901760 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 1 + i64.const 4278059008 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 7 + i64.const 4278124544 + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 8 + local.get $2 + i64.extend_i32_u + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=48 + local.get $4 + local.get $0 + local.get $1 + call $assembly/spi/StandardProgram#constructor + global.get $~lib/memory/__stack_pointer + i32.const 52 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/interpreter/Interpreter#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 33 + i32.const 29 + call $~lib/rt/itcms/__new local.tee $3 i32.store global.get $~lib/memory/__stack_pointer @@ -28202,7 +28761,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -28210,7 +28769,7 @@ i64.store global.get $~lib/memory/__stack_pointer i32.const 8 - i32.const 51 + i32.const 46 call $~lib/rt/itcms/__new local.tee $0 i32.store @@ -28271,277 +28830,580 @@ local.get $3 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $~lib/util/string/joinIntegerArray (param $0 i32) (param $1 i32) (result i32) + (func $~lib/array/Array#__set (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $1 + local.get $0 + i32.load offset=12 + i32.ge_u + if + local.get $1 + i32.const 0 + i32.lt_s + if + i32.const 1504 + i32.const 9152 + i32.const 130 + i32.const 22 + call $~lib/builtins/abort + unreachable + end + local.get $0 + local.get $1 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + i32.store offset=12 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $1 + i32.const 2 + i32.shl + i32.add + local.get $2 + i32.store + local.get $0 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#set:length (param $0 i32) (param $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + local.get $1 + i32.const 2 + i32.const 0 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/array/Array#push (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $0 + i32.load offset=12 + local.tee $2 + i32.const 1 + i32.add + local.tee $3 + i32.const 2 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + local.get $2 + i32.const 2 + i32.shl + i32.add + local.get $1 + i32.store + local.get $0 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/memory/Memory#free (param $0 i32) + (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $1 - i32.const 1 - i32.sub - local.tee $4 - i32.const 0 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15424 - return - end - local.get $4 - i32.eqz - if - local.get $0 - i64.load - i32.const 10 - call $~lib/util/number/utoa64 - local.set $0 - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 18412 - i32.load - i32.const 1 - i32.shr_u - local.tee $5 - i32.const 20 - i32.add - local.get $4 - i32.mul - i32.const 20 - i32.add - local.tee $6 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store offset=4 - loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load offset=8 + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load offset=16 + local.set $6 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 47 + call $~lib/rt/itcms/__new + local.tee $8 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + i32.store + local.get $8 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + i32.store offset=12 + local.get $6 + i32.const 268435455 + i32.gt_u + if + i32.const 9200 + i32.const 9152 + i32.const 70 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + local.get $6 + local.get $6 + i32.const 8 + i32.le_u + select + i32.const 2 + i32.shl + local.tee $9 + i32.const 1 + call $~lib/rt/itcms/__new + local.tee $7 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $8 + local.get $7 + i32.store + local.get $8 + local.get $7 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $9 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + local.get $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + loop $for-loop|0 + local.get $3 + local.get $6 + i32.lt_s + if + local.get $5 local.get $3 - local.get $4 - i32.lt_s + i32.const 12 + i32.mul + i32.add + local.tee $7 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz if + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + local.get $8 + local.get $1 + local.get $7 + call $~lib/array/Array#__set local.get $1 - local.get $2 - i32.const 1 - i32.shl - i32.add - local.get $0 - local.get $3 - i32.const 3 - i32.shl - i32.add - i64.load - call $~lib/util/number/itoa_buffered - local.get $2 - i32.add - local.set $2 - local.get $5 - if - local.get $1 - local.get $2 - i32.const 1 - i32.shl - i32.add - i32.const 18416 - local.get $5 - i32.const 1 - i32.shl - memory.copy - local.get $2 - local.get $5 - i32.add - local.set $2 - end - local.get $3 i32.const 1 i32.add - local.set $3 - br $for-loop|0 + local.set $1 end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 end - local.get $6 - local.get $1 - local.get $2 - i32.const 1 - i32.shl - i32.add - local.get $0 - local.get $4 - i32.const 3 - i32.shl - i32.add - i64.load - call $~lib/util/number/itoa_buffered + end + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $1 + call $~lib/array/Array#set:length + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + loop $for-loop|00 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + call $~lib/array/Array#get:length local.get $2 - i32.add - local.tee $2 i32.gt_s if global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $1 i32.store - local.get $1 - local.set $0 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $8 + i32.store offset=16 + local.get $8 + local.get $2 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=4 + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner0 + br_if $folding-inner1 global.get $~lib/memory/__stack_pointer i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $2 - i32.const 0 - local.get $2 i32.const 0 - i32.gt_s - select - local.tee $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $1 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 local.get $1 + local.get $3 + call $~lib/array/Array#push + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer local.get $2 - i32.gt_s - select - local.tee $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.le_s - select i32.const 1 - i32.shl - local.set $3 - block $__inlined_func$~lib/string/String#substring$2458 - local.get $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.ge_s - select - i32.const 1 - i32.shl - local.tee $2 - local.get $3 - i32.sub - local.tee $4 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15424 - local.set $0 - br $__inlined_func$~lib/string/String#substring$2458 - end - local.get $3 - i32.eqz - local.get $2 - local.get $1 - i32.const 1 - i32.shl - i32.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#substring$2458 - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store offset=4 - local.get $1 - local.get $0 - local.get $3 - i32.add - local.get $4 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - local.set $0 - end - br $folding-inner1 + i32.add + local.set $2 + br $for-loop|00 end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 16 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.store + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 48 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 4 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + return end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable ) - (func $~lib/staticarray/StaticArray#join (param $0 i32) (result i32) - (local $1 i32) + (func $assembly/api-debugger/fillRegisters (param $0 i32) (param $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i64) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -28551,37 +29413,162 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + i32.store local.get $0 i32.const 20 i32.sub i32.load offset=16 - i32.const 3 - i32.shr_u - local.set $1 + i32.const -8 + i32.and + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 18416 + local.get $1 i32.store - local.get $0 local.get $1 - call $~lib/util/string/joinIntegerArray + call $~lib/array/Array#get:length + local.get $3 + i32.ne + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/array/Array#get:length + call $~lib/number/I32#toString + local.tee $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + call $~lib/number/I32#toString + local.tee $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 19584 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + i32.const 19588 + local.get $0 + i32.store + i32.const 19584 + local.get $0 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19584 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + i32.const 19596 + local.get $1 + i32.store + i32.const 19584 + local.get $1 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 19584 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store offset=12 + i32.const 19584 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 19360 + i32.const 192 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $2 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.lt_s + if + i64.const 0 + local.set $4 + i32.const 0 + local.set $3 + loop $for-loop|1 + local.get $3 + i32.const 8 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $4 + local.get $1 + local.get $2 + i32.const 3 + i32.shl + local.get $3 + i32.add + call $~lib/array/Array#__get + i64.extend_i32_u + local.get $3 + i32.const 3 + i32.shl + i32.const 255 + i32.and + i64.extend_i32_u + i64.shl + i64.or + local.set $4 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $2 + local.get $4 + call $~lib/staticarray/StaticArray#__set + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 + end + end global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/api-generic/runVm~anonymous|0 (param $0 i64) (param $1 i32) (param $2 i32) (result i32) + (func $assembly/api-internal/InitialChunk#constructor (result i32) + (local $0 i32) + (local $1 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -28591,833 +29578,789 @@ i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i32.const 17728 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 50 + call $~lib/rt/itcms/__new + local.tee $0 i32.store + global.get $~lib/memory/__stack_pointer local.get $0 - i32.const 16 - call $~lib/util/number/utoa64 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 19696 + call $~lib/rt/__newArray local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 i32.store offset=4 - i32.const 17728 + local.get $0 local.get $1 - call $~lib/string/String#concat + i32.const 0 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer + local.get $0 ) - (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) + (func $assembly/api-internal/buildMemory (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) - (local $7 i64) + (local $7 i32) + (local $8 i32) + (local $9 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 24 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - local.tee $5 - i32.const 2 - i32.const 52 i32.const 0 - call $~lib/rt/__newArray - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=4 - local.set $6 + i32.const 24 + memory.fill + i32.const 65536 + local.set $3 loop $for-loop|0 - local.get $2 - local.get $5 - i32.lt_s + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + call $~lib/array/Array#get:length + local.get $4 + i32.gt_s if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $4 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer local.get $0 - local.get $2 - i32.const 3 - i32.shl - i32.add - i64.load + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + i32.load offset=8 + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + i32.load local.set $7 global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + i32.load offset=4 + call $~lib/typedarray/Uint8Array#constructor + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=8 local.get $0 + local.get $8 + local.get $7 + local.get $9 + call $assembly/memory/MemoryBuilder#setData + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load offset=8 + i32.const 2 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $3 + local.get $6 + i32.load + i32.le_u + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load + local.set $3 + end + end + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/array/Array#get:length + local.get $5 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $2 i32.store - i32.const 3 - global.set $~argumentsLength global.get $~lib/memory/__stack_pointer - local.get $7 local.get $2 + local.get $5 + call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get + local.tee $1 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + call $~lib/array/Array#get:length + call $~lib/typedarray/Uint8Array#constructor + local.tee $6 + i32.store offset=20 + i32.const 0 + local.set $4 + loop $for-loop|2 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + call $~lib/typedarray/Uint8Array#get:length + local.get $4 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + local.get $6 + local.get $4 + local.get $7 + local.get $4 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|2 + end + end + global.get $~lib/memory/__stack_pointer local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 local.get $1 i32.load - call_indirect (type $12) - local.tee $4 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $6 i32.store offset=8 + local.get $0 + i32.const 0 + local.get $1 local.get $6 - local.get $2 - i32.const 2 - i32.shl - i32.add - local.get $4 - i32.store - local.get $3 - local.get $4 - i32.const 1 - call $~lib/rt/itcms/__link - local.get $2 + call $assembly/memory/MemoryBuilder#setData + local.get $5 i32.const 1 i32.add - local.set $2 - br $for-loop|0 + local.set $5 + br $for-loop|1 end end global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/array/Array<~lib/string/String>#join (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer local.get $0 i32.store local.get $0 - i32.load offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store - i32.const 18416 - call $~lib/util/string/joinStringArray + local.get $3 + call $assembly/memory/MemoryBuilder#build global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 24 i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/program/resolveArguments (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i64) - (local $5 i32) + (func $assembly/api-debugger/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) (param $5 i32) (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 40 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner6 - block $folding-inner5 - block $folding-inner4 - block $folding-inner3 - block $folding-inner2 - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - local.get $2 - call $assembly/program/decodeArguments - local.tee $2 - i32.store offset=4 - local.get $2 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.const 54 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - call $~lib/object/Object#constructor - local.tee $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - call $assembly/arguments/Args#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $6 - local.get $1 - i32.store offset=32 - local.get $6 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i32.store offset=32 - local.get $6 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - block $case13|0 - block $case12|0 - block $case11|0 - block $case8|0 - block $case5|0 - block $case4|0 - block $case2|0 - local.get $0 - br_table $folding-inner6 $folding-inner1 $case2|0 $folding-inner1 $case4|0 $case5|0 $folding-inner3 $folding-inner3 $case8|0 $folding-inner4 $folding-inner4 $case11|0 $case12|0 $case13|0 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s - i64.store - br $folding-inner2 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - br $folding-inner2 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - i64.load32_u - i64.const 32 - i64.shl - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $4 - local.get $2 - i64.load32_u offset=4 - i64.add - i64.store offset=8 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=8 - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=12 - i64.store offset=24 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=8 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=16 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - i32.const 19552 - i32.store - local.get $0 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - i32.const 19552 - local.get $0 - call $~lib/string/String#concat - i32.const 19632 - i32.const 347 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s - i64.store - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=4 - i64.store offset=8 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=4 - i64.store offset=8 - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $5 + if (result i32) global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 + local.get $0 + i32.store offset=8 + local.get $0 + call $assembly/program/liftBytes + local.set $0 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store + local.get $0 + i32.store offset=4 + local.get $0 + call $assembly/program/extractCodeAndMetadata + local.set $0 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $0 i32.store + local.get $0 + i32.load + else global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 + local.get $0 + i32.store + local.get $0 + call $assembly/program/liftBytes end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 + local.tee $0 i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=8 - i64.store offset=16 - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $assembly/interpreter/branch (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer + local.get $0 + i32.store global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 + local.get $0 + call $assembly/program/deblob + local.tee $7 + i32.store offset=16 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + i32.const 13 + call $~lib/staticarray/StaticArray#constructor + local.tee $5 + i32.store offset=20 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 56 - call $~lib/rt/itcms/__new - local.tee $4 + local.get $5 i32.store global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $1 i32.store offset=4 + local.get $5 + local.get $1 + call $assembly/api-debugger/fillRegisters global.get $~lib/memory/__stack_pointer - local.get $4 - call $~lib/object/Object#constructor - local.tee $4 + call $assembly/memory/MemoryBuilder#constructor + local.tee $8 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $8 i32.store global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store8 global.get $~lib/memory/__stack_pointer - local.get $4 + local.get $2 + i32.store offset=28 + block $__inlined_func$assembly/api-debugger/readPages$23 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 19632 + call $~lib/rt/__newArray + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + call $assembly/codec/Decoder#constructor + local.tee $2 + i32.store offset=8 + loop $while-continue|0 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner00 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.const 48 + call $~lib/rt/itcms/__new + local.tee $9 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + call $~lib/object/Object#constructor + local.tee $9 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $9 + local.get $2 + call $assembly/codec/Decoder#u32 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $9 + local.get $2 + call $assembly/codec/Decoder#u32 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $9 + i32.const 2 + i32.const 1 + local.get $2 + call $assembly/codec/Decoder#u8 + select + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=16 + local.get $1 + local.get $9 + call $~lib/array/Array#push + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + br $__inlined_func$assembly/api-debugger/readPages$23 + end + br $folding-inner1 + end + local.set $9 + global.get $~lib/memory/__stack_pointer + local.get $9 i32.store offset=4 - local.get $4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer i32.const 0 + i32.const 2 + i32.const 51 + i32.const 19664 + call $~lib/rt/__newArray + local.tee $10 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $3 + call $assembly/codec/Decoder#constructor + local.tee $1 + i32.store offset=8 + loop $while-continue|01 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $assembly/codec/Decoder#isExhausted + i32.eqz + if + global.get $~lib/memory/__stack_pointer + call $assembly/api-internal/InitialChunk#constructor + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + local.get $2 + local.get $1 + call $assembly/codec/Decoder#u32 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + call $assembly/codec/Decoder#u32 + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $11 + call $assembly/codec/Decoder#bytes + local.tee $6 + i32.store offset=20 + i32.const 0 + local.set $3 + loop $for-loop|1 + local.get $3 + local.get $11 + i32.lt_u + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + local.tee $12 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=16 + local.get $12 + local.get $6 + local.get $3 + call $~lib/typedarray/Uint8Array#__get + call $~lib/array/Array#push + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|1 + end + end + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $10 + local.get $2 + call $~lib/array/Array#push + br $while-continue|01 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 24 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $8 + local.get $9 + local.get $10 + call $assembly/api-internal/buildMemory + local.tee $0 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $7 + local.get $5 + local.get $0 + call $assembly/interpreter/Interpreter#constructor + local.tee $0 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $1 i32.store + local.get $1 + local.get $4 + call $assembly/gas/GasCounter#set@override + local.get $0 + global.set $assembly/api-debugger/interpreter + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/program/BasicBlocks#isStart (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $2 + i32.store + local.get $1 + local.get $2 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 2 + i32.shr_u + i32.lt_u + if global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + i32.const 2 + i32.and + i32.const 0 + i32.ne + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $assembly/interpreter/branch (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - local.get $0 + i32.const 8 + i32.const 53 + call $~lib/rt/itcms/__new + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 + local.get $4 + call $~lib/object/Object#constructor + local.tee $4 i32.store - block $__inlined_func$assembly/program/BasicBlocks#isStart$2459 - local.get $1 - local.get $2 - i32.add - local.tee $1 - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - i32.const 2 - i32.and - i32.const 0 - i32.ne - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$assembly/program/BasicBlocks#isStart$2459 - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - local.set $0 - end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.store8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 local.get $0 + local.get $1 + local.get $2 + i32.add + local.tee $0 + call $assembly/program/BasicBlocks#isStart if global.get $~lib/memory/__stack_pointer local.get $4 @@ -29429,7 +30372,7 @@ local.get $4 i32.store offset=4 local.get $4 - local.get $1 + local.get $0 i32.store offset=4 end global.get $~lib/memory/__stack_pointer @@ -29439,8 +30382,8 @@ local.get $4 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -29461,7 +30404,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner6 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner6 global.get $~lib/memory/__stack_pointer @@ -29832,10 +30775,10 @@ i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer - block $__inlined_func$assembly/interpreter/dJump$17 + block $__inlined_func$assembly/interpreter/dJump$24 block $folding-inner11 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner6 global.get $~lib/memory/__stack_pointer @@ -29850,7 +30793,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner6 global.get $~lib/memory/__stack_pointer @@ -29858,7 +30801,7 @@ i64.store global.get $~lib/memory/__stack_pointer i32.const 8 - i32.const 55 + i32.const 52 call $~lib/rt/itcms/__new local.tee $5 i32.store @@ -29898,7 +30841,7 @@ local.get $5 i32.const 1 i32.store - br $__inlined_func$assembly/interpreter/dJump$17 + br $__inlined_func$assembly/interpreter/dJump$24 end local.get $3 i32.const 1 @@ -29950,7 +30893,7 @@ local.get $5 local.get $2 i64.store32 offset=4 - br $__inlined_func$assembly/interpreter/dJump$17 + br $__inlined_func$assembly/interpreter/dJump$24 end global.get $~lib/memory/__stack_pointer local.get $5 @@ -30197,8 +31140,8 @@ i32.store offset=24 br $folding-inner5 end - i32.const 19968 - i32.const 20016 + i32.const 19728 + i32.const 19776 i32.const 173 i32.const 9 call $~lib/builtins/abort @@ -30227,737 +31170,1522 @@ i32.store local.get $0 i32.const 4 - i32.store offset=20 - br $folding-inner5 + i32.store offset=20 + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 1 + i32.store offset=20 + br $folding-inner5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.load offset=4 + i32.store offset=16 + end + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 1 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api-debugger/nextStep (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api-debugger/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 69 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + call $assembly/interpreter/Interpreter#nextStep + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $assembly/api-debugger/nSteps (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api-debugger/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 77 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + i32.const 1 + local.set $2 + loop $for-loop|0 + local.get $0 + local.get $3 + i32.gt_u + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $assembly/interpreter/Interpreter#nextStep + local.tee $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + ) + (func $assembly/api-debugger/getProgramCounter (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 94 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=16 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-debugger/setNextProgramCounter (param $0 i32) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 102 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + local.get $0 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-debugger/getStatus (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 1 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 110 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=20 + i32.const 255 + i32.and + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-debugger/getExitArg (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 118 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + i32.load offset=24 + local.tee $0 + i32.eqz + if + i32.const 0 + local.set $0 + end + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $assembly/api-debugger/getGasLeft (result i64) + (local $0 i32) + (local $1 i64) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + i64.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 126 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $0 + i32.store offset=8 + local.get $0 + call $assembly/gas/GasCounter#get@override + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-debugger/setGasLeft (param $0 i64) + (local $1 i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api-debugger/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 132 + i32.const 30 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=12 + local.tee $1 + i32.store offset=8 + local.get $1 + local.get $0 + call $assembly/gas/GasCounter#set@override + end + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-debugger/getRegisters (result i32) + (local $0 i32) + (local $1 i32) + (local $2 i64) + (local $3 i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 104 + call $~lib/typedarray/Uint8Array#constructor + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + i32.const 1 + global.set $~argumentsLength + local.get $3 + call $~lib/typedarray/Uint8Array#fill@varargs + local.tee $4 + i32.store offset=4 + global.get $assembly/api-debugger/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $3 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 143 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.store offset=12 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=4 + local.tee $0 + i32.store + local.get $1 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + local.get $1 + call $~lib/staticarray/StaticArray#__get + local.set $2 + i32.const 0 + local.set $0 + loop $for-loop|1 + local.get $0 + i32.const 8 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $1 + i32.const 3 + i32.shl + local.get $0 + i32.add + local.get $2 + i64.const 255 + i64.and + i32.wrap_i64 + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i64.const 8 + i64.shr_u + local.set $2 + local.get $0 + i32.const 1 + i32.add + local.set $0 + br $for-loop|1 + end + end + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + ) + (func $assembly/api-debugger/getPageDump (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $assembly/api-debugger/interpreter + i32.eqz + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 168 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.tee $1 + i32.store + block $__inlined_func$assembly/memory/Memory#pageDump$2492 + local.get $1 + local.get $0 + call $"~lib/map/Map#has" + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + local.set $0 + br $__inlined_func$assembly/memory/Memory#pageDump$2492 + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.tee $1 + i32.store offset=8 + local.get $1 + local.get $0 + call $"~lib/map/Map#get" + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $0 + i32.store + local.get $0 + call $assembly/memory-page/RawPage#get:data + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + end + local.get $0 + i32.store offset=16 + local.get $0 + i32.eqz + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return + end + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + i32.const 4096 + call $~lib/typedarray/Uint8Array#constructor + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + i32.const 1 + global.set $~argumentsLength + local.get $0 + call $~lib/typedarray/Uint8Array#fill@varargs + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-utils/prepareProgram (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (result i32) + (local $7 i32) + (local $8 i64) + global.get $~lib/memory/__stack_pointer + i32.const 48 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 48 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + call $assembly/program/liftBytes + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.tee $7 + i32.store offset=8 + local.get $1 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + call $assembly/program/extractCodeAndMetadata + local.tee $1 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + end + local.get $0 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + call $assembly/program/deblob + local.tee $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + call $assembly/memory/MemoryBuilder#constructor + local.tee $1 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $1 + local.get $4 + local.get $5 + call $assembly/api-internal/buildMemory + local.tee $2 + i32.store offset=32 + global.get $~lib/memory/__stack_pointer + i32.const 13 + call $~lib/staticarray/StaticArray#constructor + local.tee $4 + i32.store offset=36 + i32.const 0 + local.set $1 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.get $1 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $1 + local.get $3 + i32.load offset=12 + i32.ge_u + if + i32.const 1504 + i32.const 9152 + i32.const 114 + i32.const 42 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=4 + local.get $1 + i32.const 3 + i32.shl + i32.add + i64.load + local.set $8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + local.get $1 + local.get $8 + call $~lib/staticarray/StaticArray#__set + local.get $1 + i32.const 1 + i32.add + local.set $1 + br $for-loop|0 end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store offset=20 - br $folding-inner5 end global.get $~lib/memory/__stack_pointer local.get $0 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 + local.get $2 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer local.get $0 + local.get $2 + local.get $4 + call $assembly/spi/StandardProgram#constructor + local.tee $0 + i32.store offset=40 + br $folding-inner1 + end + local.get $0 + i32.const 1 + i32.eq + if + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=28 + local.get $6 + call $assembly/program/liftBytes + local.set $1 + global.get $~lib/memory/__stack_pointer local.get $1 - i32.load offset=4 - i32.store offset=16 + i32.store offset=24 + local.get $2 + local.get $1 + call $assembly/spi/decodeSpi + local.tee $0 + i32.store offset=44 + br $folding-inner1 end global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 1 - return + i32.const 19984 + i32.store + local.get $0 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=24 + i32.const 19984 + local.get $0 + call $~lib/string/String#concat + i32.const 20032 + i32.const 81 + i32.const 3 + call $~lib/builtins/abort + unreachable end - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/array/Array#set:length (param $0 i32) (param $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - local.get $1 - i32.const 2 - i32.const 0 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#push (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $0 - i32.load offset=12 - local.tee $2 - i32.const 1 - i32.add - local.tee $3 - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.load offset=4 - i32.add - local.get $1 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-generic/InitialChunk#constructor (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 45 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer local.get $0 - call $~lib/object/Object#constructor - local.tee $0 i32.store global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=24 local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 + local.get $7 i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 20192 - call $~lib/rt/__newArray - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=4 local.get $0 - local.get $1 + local.get $7 i32.const 0 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 48 i32.add global.set $~lib/memory/__stack_pointer local.get $0 ) - (func $~lib/array/Array#push (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $0 - i32.load offset=12 - local.tee $2 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $2 - i32.const 2 - i32.shl - i32.add - local.get $1 - i32.store - local.get $0 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-generic/getOutputChunks (param $0 i32) (result i32) + (func $assembly/gas-costs/computeGasCosts (param $0 i32) (result i32) (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) global.get $~lib/memory/__stack_pointer - i32.const 32 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner1 + block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner1 + br_if $folding-inner0 global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 32 + i32.const 20 memory.fill global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 20160 - call $~lib/rt/__newArray - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer local.get $0 - i32.load offset=8 - local.tee $5 i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.load offset=8 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $0 + i32.load + local.tee $3 i32.store - local.get $5 - i32.load offset=16 - local.set $8 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + local.set $3 global.get $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner1 + br_if $folding-inner0 global.get $~lib/memory/__stack_pointer i64.const 0 i64.store global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 42 + i32.const 24 + i32.const 57 call $~lib/rt/itcms/__new - local.tee $9 + local.tee $5 i32.store global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $5 i32.store offset=4 - local.get $9 - i32.const 0 + i32.const 16 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + local.get $5 + local.get $6 i32.store - local.get $9 - i32.const 0 + local.get $5 + local.get $6 i32.const 0 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 + local.get $5 i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $5 + i32.const 3 i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $5 i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=12 - local.get $8 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9152 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end + i32.const 48 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $6 global.get $~lib/memory/__stack_pointer - i32.const 8 - local.get $8 - local.get $8 - i32.const 8 - i32.le_u - select - i32.const 2 - i32.shl - local.tee $10 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $5 + local.get $6 i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $9 local.get $5 - i32.store - local.get $9 + local.get $6 + i32.store offset=8 local.get $5 + local.get $6 i32.const 0 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 local.get $5 i32.store offset=4 + local.get $5 + i32.const 4 + i32.store offset=12 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $5 i32.store offset=4 - local.get $9 - local.get $10 - i32.store offset=8 + local.get $5 + i32.const 0 + i32.store offset=16 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $5 i32.store offset=4 - local.get $9 - local.get $8 - i32.store offset=12 + local.get $5 + i32.const 0 + i32.store offset=20 global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 + local.get $5 + i32.store offset=8 loop $for-loop|0 local.get $2 - local.get $8 + local.get $3 i32.lt_s if - local.get $7 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $4 + i32.store + local.get $4 local.get $2 - i32.const 12 - i32.mul - i32.add - local.tee $5 - i32.load offset=8 - i32.const 1 - i32.and + call $assembly/program/Mask#isInstruction i32.eqz if - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $1 - local.get $5 - i32.load - call $~lib/array/Array#__set - local.get $1 - i32.const 1 - i32.add - local.set $1 + i32.const 15536 + i32.const 20096 + i32.const 16 + i32.const 7 + call $~lib/builtins/abort + unreachable end - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $1 - call $~lib/array/Array#set:length - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - i32.const 0 - local.set $1 - loop $for-loop|00 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/array/Array#get:length - local.get $4 - i32.gt_s - if global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $0 i32.store offset=4 - local.get $9 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $4 + i32.store local.get $4 - call $~lib/array/Array#__get - local.set $5 + local.get $2 + call $~lib/typedarray/Uint8Array#__get + local.set $4 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 + global.get $assembly/instructions/INSTRUCTIONS + local.tee $6 + i32.store + local.get $4 + local.get $6 + call $~lib/array/Array#get:length + i32.const 255 + i32.and + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $6 + i32.store + local.get $6 + local.get $4 + call $~lib/array/Array#__get + end + local.set $4 global.get $~lib/memory/__stack_pointer local.get $0 - i32.load offset=8 - local.tee $2 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $5 - call $"~lib/map/Map#get" + local.get $0 + i32.load offset=12 local.tee $6 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer + i32.store local.get $6 - i32.load offset=4 - local.tee $2 - i32.store offset=4 local.get $2 - i32.load offset=4 + call $assembly/program/BasicBlocks#isStart if - i32.const 0 - local.set $2 - loop $for-loop|1 + local.get $1 + if global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 + local.get $5 + i32.store global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - local.get $7 - call $assembly/memory-page/RawPage#get:data - local.set $7 + local.get $1 + i32.store offset=12 + local.get $1 + i32.load + local.set $6 global.get $~lib/memory/__stack_pointer - local.get $7 + local.get $1 i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - local.get $7 - call $assembly/memory-page/RawPage#get:data - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $2 - call $~lib/typedarray/Uint8Array#__get - local.tee $7 - if - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $8 - i32.store offset=4 - local.get $8 - local.get $7 - call $~lib/array/Array#push - else - global.get $~lib/memory/__stack_pointer - call $assembly/api-generic/InitialChunk#constructor - local.tee $1 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $5 - i32.const 12 - i32.shl - local.get $2 - i32.add - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 1 - i32.const 0 - i32.const 27 - i32.const 0 - call $~lib/rt/__newArray - local.tee $8 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.load offset=12 - i32.eqz - if - local.get $8 - i32.const 1 - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - i32.store offset=12 - end - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.load offset=4 - local.get $7 - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $1 - local.get $8 - i32.store offset=4 - local.get $1 - local.get $8 - i32.const 0 - call $~lib/rt/itcms/__link - end - else - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - call $~lib/array/Array#push - i32.const 0 - local.set $1 - end - end - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end + local.get $5 + local.get $6 + local.get $1 + call $"~lib/map/Map#set" end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 54 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/object/Object#constructor + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.get $2 + i32.store + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $1 + i64.load offset=8 + local.get $4 + i64.load offset=8 + i64.add + i64.store offset=8 end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $4 + i32.store local.get $4 + local.get $2 + call $assembly/program/Mask#skipBytesToNextInstruction + local.get $2 + i32.add i32.const 1 i32.add - local.set $4 - br $for-loop|00 + local.set $2 + br $for-loop|0 end end local.get $1 if global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 + local.get $5 + i32.store global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=8 - local.get $3 + i32.store offset=12 + local.get $1 + i32.load + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $5 + local.get $0 local.get $1 - call $~lib/array/Array#push + call $"~lib/map/Map#set" end global.get $~lib/memory/__stack_pointer - i32.const 32 + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $5 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $"~lib/map/Map#values" (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) + (func $assembly/api-utils/getGasCosts (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) + (local $8 i32) global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 24 i32.sub global.set $~lib/memory/__stack_pointer block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 3 + i32.const 56 + i32.const 19856 + call $~lib/rt/__newArray + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 19888 + call $~lib/rt/__newArray + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + i32.const 0 + i32.const 2 + i32.const 51 + i32.const 19920 + call $~lib/rt/__newArray + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 19952 + call $~lib/rt/__newArray + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $1 + local.get $2 + local.get $0 + local.get $4 + local.get $5 + local.get $6 + local.get $8 + call $assembly/api-utils/prepareProgram + local.tee $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=16 + local.tee $0 + i32.store offset=4 + local.get $0 + call $assembly/gas-costs/computeGasCosts + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -30971,20 +32699,20 @@ i32.store local.get $0 i32.load offset=8 - local.set $4 + local.set $1 global.get $~lib/memory/__stack_pointer local.get $0 i32.store local.get $0 i32.load offset=16 - local.set $2 + local.set $0 global.get $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -30995,39 +32723,39 @@ i64.store offset=8 global.get $~lib/memory/__stack_pointer i32.const 16 - i32.const 57 + i32.const 55 call $~lib/rt/itcms/__new - local.tee $6 + local.tee $4 i32.store global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store offset=4 - local.get $6 + local.get $4 i32.const 0 i32.store - local.get $6 + local.get $4 i32.const 0 i32.const 0 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store offset=4 - local.get $6 + local.get $4 i32.const 0 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store offset=4 - local.get $6 + local.get $4 i32.const 0 i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store offset=4 - local.get $6 + local.get $4 i32.const 0 i32.store offset=12 - local.get $2 + local.get $0 i32.const 268435455 i32.gt_u if @@ -31040,61 +32768,63 @@ end global.get $~lib/memory/__stack_pointer i32.const 8 - local.get $2 - local.get $2 + local.get $0 + local.get $0 i32.const 8 i32.le_u select i32.const 2 i32.shl - local.tee $0 + local.tee $2 i32.const 1 call $~lib/rt/itcms/__new local.tee $5 i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $5 i32.store offset=12 - local.get $6 + local.get $4 local.get $5 i32.store - local.get $6 + local.get $4 local.get $5 i32.const 0 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store offset=4 - local.get $6 + local.get $4 local.get $5 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store offset=4 - local.get $6 - local.get $0 + local.get $4 + local.get $2 i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store offset=4 - local.get $6 - local.get $2 + local.get $4 + local.get $0 i32.store offset=12 global.get $~lib/memory/__stack_pointer i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store offset=4 + i32.const 0 + local.set $2 loop $for-loop|0 - local.get $2 + local.get $0 local.get $3 i32.gt_s if - local.get $4 + local.get $1 local.get $3 i32.const 12 i32.mul @@ -31106,82 +32836,21 @@ i32.eqz if global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store - local.get $1 - local.tee $0 - i32.const 1 - i32.add - local.set $1 global.get $~lib/memory/__stack_pointer local.get $5 i32.load offset=4 - local.tee $7 + local.tee $5 i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $0 - local.get $6 - i32.load offset=12 - i32.ge_u - if - local.get $0 - i32.const 0 - i32.lt_s - if - i32.const 1504 - i32.const 9152 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $6 - local.get $0 - i32.const 1 - i32.add - local.tee $5 - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $5 - i32.store offset=12 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load offset=4 - local.get $0 - i32.const 2 - i32.shl - i32.add - local.get $7 - i32.store - local.get $6 - local.get $7 + local.get $4 + local.get $2 + local.get $5 + call $~lib/array/Array#__set + local.get $2 i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 4 i32.add - global.set $~lib/memory/__stack_pointer + local.set $2 end local.get $3 i32.const 1 @@ -31191,1454 +32860,879 @@ end end global.get $~lib/memory/__stack_pointer - local.get $6 + local.get $4 i32.store - local.get $6 - local.get $1 - call $~lib/array/Array#set:length + local.get $4 + local.get $2 + call $~lib/array/Array#set:length global.get $~lib/memory/__stack_pointer i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - local.get $6 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $assembly/api-generic/runVm (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) + (func $assembly/api-utils/disassemble~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) (local $4 i32) - (local $5 i64) + (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $14 i32) - (local $15 i32) - (local $16 i32) - (local $17 i32) global.get $~lib/memory/__stack_pointer - i32.const 124 + i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner1 + block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner1 + br_if $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 124 - memory.fill + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 global.get $~lib/memory/__stack_pointer local.get $0 + i32.store + local.get $1 + i32.const 255 + i32.and + i32.const 16 + call $~lib/util/number/utoa32 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=16 - local.tee $7 - i32.store offset=4 - local.get $7 - call $assembly/program/liftBytes - local.set $7 + i32.const 16080 + i32.store offset=12 global.get $~lib/memory/__stack_pointer - local.get $7 + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 i32.store - local.get $7 - call $assembly/program/deblob - local.tee $10 - i32.store offset=12 + local.get $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const -2 + i32.and + local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 13 - call $~lib/staticarray/StaticArray#constructor - local.tee $6 - i32.store offset=16 - loop $for-loop|0 + i32.const 16080 + i32.store + block $__inlined_func$~lib/string/String#padStart$2530 + i32.const 16076 + i32.load + i32.const -2 + i32.and + local.tee $2 + i32.eqz + local.get $5 + i32.const 4 + i32.gt_u + i32.or + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$~lib/string/String#padStart$2530 + end global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $3 - local.get $6 - i32.const 20 + i32.const 4 + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $3 + i32.store offset=4 + i32.const 4 + local.get $5 i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.lt_s + local.tee $4 + local.get $2 + i32.gt_u if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load + local.get $4 + local.get $4 + i32.const 2 + i32.sub + local.get $2 + i32.div_u + local.get $2 + i32.mul local.tee $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 4 i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $3 - local.get $7 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable + local.set $8 + loop $while-continue|0 + local.get $6 + local.get $7 + i32.lt_u + if + local.get $3 + local.get $6 + i32.add + i32.const 16080 + local.get $2 + memory.copy + local.get $2 + local.get $6 + i32.add + local.set $6 + br $while-continue|0 + end end - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - i32.load offset=4 local.get $3 - i32.const 3 - i32.shl - i32.add - i64.load - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $7 i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - local.get $3 - local.get $5 - call $~lib/staticarray/StaticArray#__set + i32.const 16080 + local.get $8 + memory.copy + else local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 + i32.const 16080 + local.get $4 + memory.copy end + local.get $3 + local.get $4 + i32.add + local.get $1 + local.get $5 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + local.set $1 end global.get $~lib/memory/__stack_pointer - call $assembly/memory/MemoryBuilder#constructor - local.tee $3 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=20 - local.tee $7 + local.get $1 i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer local.get $0 - i32.load offset=24 - local.tee $8 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $7 - local.get $8 - call $assembly/api-generic/buildMemory - local.tee $3 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 + local.get $1 + call $~lib/string/String.__concat global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $assembly/api-utils/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 global.get $~lib/memory/__stack_pointer - local.get $10 - local.get $6 - local.get $3 - call $assembly/interpreter/Interpreter#constructor - local.tee $11 - i32.store offset=32 + i32.const 21764 + i32.lt_s + br_if $folding-inner0 global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $2 - i32.store8 offset=32 + i32.const 0 + i32.const 32 + memory.fill global.get $~lib/memory/__stack_pointer - local.get $11 + local.get $0 i32.store global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $11 - local.get $0 - i32.load offset=4 - i32.store offset=28 + i32.const 0 + i32.const 3 + i32.const 56 + i32.const 20160 + call $~lib/rt/__newArray + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $11 + local.get $5 i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 49 + i32.const 20192 + call $~lib/rt/__newArray + local.set $6 global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=12 - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i64.load offset=8 - call $assembly/gas/GasCounter#set@override - i32.const 1 - local.set $0 - loop $for-loop|1 - block $for-break1 - local.get $0 - i32.eqz - if - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - call $~lib/staticarray/StaticArray#join - local.tee $0 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - i32.const 19152 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19156 - local.get $0 - i32.store - i32.const 19152 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19152 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - i32.const 19152 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 19216 - i32.store offset=40 - local.get $6 - i32.const 19216 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store offset=8 - local.get $2 - call $~lib/array/Array<~lib/string/String>#join - local.tee $0 - i32.store offset=44 - global.get $~lib/memory/__stack_pointer - i32.const 19184 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19188 - local.get $0 - i32.store - i32.const 19184 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19184 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - i32.const 19184 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 19248 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - local.get $11 - i32.load offset=20 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19248 - local.get $0 - call $~lib/string/String#concat - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - br $for-break1 - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 19312 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - local.get $11 - i32.load offset=16 - i32.const 10 - call $~lib/util/number/utoa32 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19312 - local.get $0 - call $~lib/string/String#concat - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 19344 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - local.get $11 - i32.load offset=20 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19344 - local.get $0 - call $~lib/string/String#concat - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 19056 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store offset=40 - local.get $6 - call $~lib/staticarray/StaticArray#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19056 - local.get $0 - call $~lib/string/String#concat - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 19056 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=48 - global.get $~lib/memory/__stack_pointer - i32.const 19392 - i32.store offset=52 - local.get $6 - i32.const 19392 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store offset=40 - local.get $0 - call $~lib/array/Array<~lib/string/String>#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19056 - local.get $0 - call $~lib/string/String#concat - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end - local.get $1 + local.get $6 + i32.store offset=8 + i32.const 0 + i32.const 2 + i32.const 51 + i32.const 20224 + call $~lib/rt/__newArray + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + i32.const 0 + i32.const 0 + i32.const 27 + i32.const 20256 + call $~lib/rt/__newArray + local.set $8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + local.get $1 + local.get $2 + local.get $0 + local.get $5 + local.get $6 + local.get $7 + local.get $8 + call $assembly/api-utils/prepareProgram + local.tee $1 + i32.store offset=20 + i32.const 15504 + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store offset=24 + local.get $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20288 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 20288 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 20336 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 20288 + i32.const 20336 + call $~lib/string/String.__concat + local.tee $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 20368 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store offset=16 + i32.const 15504 + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 20368 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + i32.load offset=4 + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + local.set $7 + loop $for-loop|0 + local.get $3 + local.get $7 + i32.lt_s if global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.load offset=16 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $2 - i32.store - local.get $2 - call $~lib/typedarray/Uint8Array#get:length - local.get $0 - i32.gt_u - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $0 - local.get $11 - i32.load offset=16 - call $~lib/typedarray/Uint8Array#__get - else - i32.const 0 - end - local.set $0 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $2 - i32.store - local.get $0 local.get $2 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $2 - i32.store - local.get $2 - local.get $0 - call $~lib/array/Array#__get - end - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.load offset=4 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 + i32.store offset=12 local.get $3 - local.get $11 - i32.load offset=16 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $7 - i32.store offset=56 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=60 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 255 - i32.and - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $0 - i32.store offset=64 - global.get $~lib/memory/__stack_pointer - i32.const 19504 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - i32.const 19508 - local.get $7 - i32.store - i32.const 19504 - local.get $7 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19504 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19516 - local.get $0 - i32.store - i32.const 19504 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19504 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - i32.const 19504 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load - local.tee $7 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.load - local.tee $7 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - local.get $11 - i32.load offset=16 - i32.const 1 + local.get $6 i32.add + i32.load8_u local.set $8 - i32.const 1 - global.set $~argumentsLength - local.get $7 - local.get $8 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=4 - local.tee $8 - i32.store offset=4 - local.get $7 - local.get $3 - local.get $8 - call $assembly/program/resolveArguments - local.tee $12 - i32.store offset=68 - local.get $12 - if - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load - call $~lib/util/number/itoa64 - local.tee $0 - i32.store offset=72 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.load offset=32 - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $2 - i32.store offset=76 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $3 - i32.store offset=80 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=8 - call $~lib/util/number/itoa64 - local.tee $7 - i32.store offset=84 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.load offset=32 - local.tee $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load offset=4 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $8 - i32.store offset=88 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=8 - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $13 - i32.store offset=92 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=16 - call $~lib/util/number/itoa64 - local.tee $14 - i32.store offset=96 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.load offset=32 - local.tee $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.load offset=8 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $9 - i32.store offset=100 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=16 - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $15 - i32.store offset=104 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=24 - call $~lib/util/number/itoa64 - local.tee $16 - i32.store offset=108 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.load offset=32 - local.tee $17 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.load offset=12 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $17 - i32.store offset=112 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i64.load offset=24 - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $12 - i32.store offset=116 - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 19844 - local.get $0 - i32.store - i32.const 19840 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 19852 - local.get $2 - i32.store - i32.const 19840 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - i32.const 19860 - local.get $3 - i32.store - i32.const 19840 - local.get $3 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - i32.const 19868 - local.get $7 - i32.store - i32.const 19840 - local.get $7 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - i32.const 19876 - local.get $8 - i32.store - i32.const 19840 - local.get $8 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - i32.const 19884 - local.get $13 - i32.store - i32.const 19840 - local.get $13 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - i32.const 19892 - local.get $14 - i32.store - i32.const 19840 - local.get $14 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - i32.const 19900 - local.get $9 - i32.store - i32.const 19840 - local.get $9 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store offset=8 - i32.const 19908 - local.get $15 - i32.store - i32.const 19840 - local.get $15 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - i32.const 19916 - local.get $16 - i32.store - i32.const 19840 - local.get $16 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=8 - i32.const 19924 - local.get $17 - i32.store - i32.const 19840 - local.get $17 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - i32.const 19932 - local.get $12 - i32.store - i32.const 19840 - local.get $12 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19840 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=8 - i32.const 19840 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/console/console.log - end + local.get $5 + i32.store offset=16 + i32.const 4 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $2 + local.get $8 + local.get $3 + local.get $5 + i32.const 20368 + i32.load + call_indirect (type $7) + local.tee $2 + i32.store offset=8 + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 end - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $assembly/interpreter/Interpreter#nextStep - local.set $0 - br $for-loop|1 end + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $0 + local.get $2 + call $~lib/string/String.__concat + local.tee $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 20400 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 20400 + call $~lib/string/String.__concat + local.tee $0 + i32.store offset=24 end global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 44 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - call $~lib/object/Object#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const -1 + local.get $0 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 0 - i32.const 3 - i32.const 43 - i32.const 20096 - call $~lib/rt/__newArray - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.store offset=4 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 46 - i32.const 20128 - call $~lib/rt/__newArray - local.set $2 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 local.get $1 - local.get $2 i32.store offset=12 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 + i32.load offset=16 + local.tee $1 + i32.store offset=8 local.get $1 - i64.const 0 - i64.store offset=16 + call $assembly/api-internal/getAssembly + local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 + local.get $0 local.get $1 - i32.const 0 + call $~lib/string/String.__concat + local.tee $0 i32.store offset=24 global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 32 i32.add global.set $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=120 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $1 - local.get $11 - i32.load offset=20 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=4 - local.tee $0 - i32.store offset=8 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.tee $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.gt_s - select - local.tee $2 - i32.const 3 - i32.const 43 - i32.const 0 - call $~lib/rt/__newArray - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=4 local.get $0 + return + end + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $~lib/util/string/joinIntegerArray (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $1 + i32.const 1 + i32.sub + local.tee $4 + i32.const 0 + i32.lt_s + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15504 + return + end + local.get $4 + i32.eqz + if + local.get $0 + i64.load + i32.const 10 + call $~lib/util/number/utoa64 + local.set $0 + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 17824 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 17820 + i32.load + i32.const 1 + i32.shr_u + local.tee $5 + i32.const 20 + i32.add + local.get $4 + i32.mul + i32.const 20 + i32.add + local.tee $6 + i32.const 1 + i32.shl + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store offset=4 + loop $for-loop|0 + local.get $3 + local.get $4 + i32.lt_s + if + local.get $1 + local.get $2 + i32.const 1 + i32.shl + i32.add + local.get $0 + local.get $3 + i32.const 3 + i32.shl + i32.add + i64.load + call $~lib/util/number/itoa_buffered + local.get $2 + i32.add + local.set $2 + local.get $5 + if + local.get $1 + local.get $2 + i32.const 1 + i32.shl + i32.add + i32.const 17824 + local.get $5 + i32.const 1 + i32.shl + memory.copy + local.get $2 + local.get $5 + i32.add + local.set $2 + end + local.get $3 + i32.const 1 + i32.add + local.set $3 + br $for-loop|0 + end + end + local.get $6 + local.get $1 + local.get $2 + i32.const 1 + i32.shl + i32.add + local.get $0 + local.get $4 + i32.const 3 + i32.shl + i32.add + i64.load + call $~lib/util/number/itoa_buffered + local.get $2 + i32.add + local.tee $2 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.gt_s + select + local.tee $2 + local.get $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 1 + i32.shr_u + local.tee $1 + local.get $1 + local.get $2 + i32.gt_s + select + local.tee $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.le_s + select + i32.const 1 + i32.shl + local.set $3 + block $__inlined_func$~lib/string/String#substring$2531 + local.get $2 + i32.const 0 + local.get $2 + i32.const 0 + i32.ge_s + select + i32.const 1 + i32.shl + local.tee $2 + local.get $3 + i32.sub + local.tee $4 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 15504 + local.set $0 + br $__inlined_func$~lib/string/String#substring$2531 + end + local.get $3 + i32.eqz + local.get $2 + local.get $1 + i32.const 1 + i32.shl + i32.eq + i32.and + if + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$~lib/string/String#substring$2531 + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.const 2 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store offset=4 + local.get $1 + local.get $0 + local.get $3 + i32.add + local.get $4 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + local.set $0 + end + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $1 + return + end + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) + (func $~lib/staticarray/StaticArray#join (param $0 i32) (result i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + local.set $1 + global.get $~lib/memory/__stack_pointer + i32.const 17824 + i32.store + local.get $0 + local.get $1 + call $~lib/util/string/joinIntegerArray + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-internal/executeProgram~anonymous|0 (param $0 i64) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 20336 + i32.store + local.get $0 + i32.const 16 + call $~lib/util/number/utoa64 + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 20336 + local.get $1 + call $~lib/string/String#concat + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i64) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + local.tee $5 + i32.const 2 + i32.const 61 + i32.const 0 + call $~lib/rt/__newArray + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + i32.load offset=4 + local.set $6 + loop $for-loop|0 local.get $2 - i32.const 3 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $1 - local.get $3 - i32.store offset=4 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $1 - local.get $11 - i32.load offset=16 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=12 - local.tee $0 - i32.store offset=4 - local.get $1 - local.get $0 - call $assembly/gas/GasCounter#get@override - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=8 - local.tee $0 - i32.store offset=8 - local.get $0 - call $assembly/api-generic/getOutputChunks - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=12 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $1 - local.get $11 - i32.load offset=24 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=8 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 + local.get $5 i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - call $"~lib/map/Map#values" - local.tee $2 - i32.store offset=8 - loop $for-loop|01 - global.get $~lib/memory/__stack_pointer + if + local.get $0 local.get $2 + i32.const 3 + i32.shl + i32.add + i64.load + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $0 i32.store + i32.const 3 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $7 local.get $2 - call $~lib/array/Array#get:length + local.get $0 + local.get $1 + i32.load + call_indirect (type $15) + local.tee $4 + i32.store offset=8 + local.get $6 + local.get $2 + i32.const 2 + i32.shl + i32.add local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $2 - local.get $4 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $3 - local.get $6 - call $~lib/array/Array#push - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|01 - end + i32.store + local.get $3 + local.get $4 + i32.const 1 + call $~lib/rt/itcms/__link + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|0 end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 16 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.store - local.get $0 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 48 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.store offset=8 - local.get $0 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 4 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 124 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 ) - (func $assembly/program-build/skipBytes (param $0 i32) (param $1 i32) (result i32) + (func $~lib/array/Array<~lib/string/String>#join (param $0 i32) (result i32) + (local $1 i32) global.get $~lib/memory/__stack_pointer - i32.const 24 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -32646,2266 +33740,2374 @@ end global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 24 - memory.fill - block $folding-inner3 (result i32) - block $folding-inner2 - block $folding-inner1 - block $folding-inner0 - block $case13|0 - block $case12|0 - block $case11|0 - block $case8|0 - block $case7|0 - block $case6|0 - block $case5|0 - block $case4|0 - block $case2|0 - block $case0|0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 17824 + i32.store + i32.const 17824 + call $~lib/util/string/joinStringArray + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/program/resolveArguments (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) + (local $4 i64) + (local $5 i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner6 + block $folding-inner5 + block $folding-inner4 + block $folding-inner3 + block $folding-inner2 + block $folding-inner1 + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + local.get $2 + call $assembly/program/decodeArguments + local.tee $2 + i32.store offset=4 + local.get $2 + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + i32.const 0 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 36 + i32.const 63 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/object/Object#constructor + local.tee $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + local.get $6 + i64.const 0 + i64.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + call $assembly/arguments/Args#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $6 + local.get $1 + i32.store offset=32 + local.get $6 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i32.store offset=32 + local.get $6 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + block $case13|0 + block $case12|0 + block $case11|0 + block $case8|0 + block $case5|0 + block $case4|0 + block $case2|0 local.get $0 - br_table $case0|0 $folding-inner0 $case2|0 $folding-inner0 $case4|0 $case5|0 $case6|0 $case7|0 $case8|0 $folding-inner2 $folding-inner2 $case11|0 $case12|0 $case13|0 + br_table $folding-inner6 $folding-inner1 $case2|0 $folding-inner1 $case4|0 $case5|0 $folding-inner3 $folding-inner3 $case8|0 $folding-inner4 $folding-inner4 $case11|0 $case12|0 $case13|0 end global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s + i64.store + br $folding-inner2 end global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $6 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u - i32.const 1 - i32.add - local.tee $0 - i32.const 255 - i32.and - i32.const 1 - i32.add - block $__inlined_func$assembly/program-build/immBytes$2177 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $1 - local.get $0 - i32.const 1 - i32.add - i32.const 255 - i32.and - local.tee $0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$2177 - drop - local.get $1 - local.get $0 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - i32.add - br $folding-inner3 - end - block $__inlined_func$assembly/program-build/immBytes$2179 (result i32) + local.get $3 + i32.store offset=12 global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $0 - i32.const 0 - i32.le_s - br_if $__inlined_func$assembly/program-build/immBytes$2179 - drop - local.get $0 - i32.const 1 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + br $folding-inner2 end - i32.const 1 - i32.add - br $folding-inner3 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + i64.load32_u + i64.const 32 + i64.shl + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $4 + local.get $2 + i64.load32_u offset=4 + i64.add + i64.store offset=8 + br $folding-inner6 end global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 9 - return + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + br $folding-inner6 end global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $6 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=8 - br $folding-inner1 + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=8 + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=12 + i64.store offset=24 + br $folding-inner6 end global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $6 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 + local.get $3 i32.store offset=12 - br $folding-inner1 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=8 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=16 + br $folding-inner6 end global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 1 - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u - i32.const 1 - i32.add - local.tee $0 - i32.const 255 - i32.and - i32.const 2 - i32.add - block $__inlined_func$assembly/program-build/immBytes$2185 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 + i32.const 17888 i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $1 local.get $0 - i32.const 255 - i32.and - i32.const 2 - i32.add - local.tee $0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$2185 - drop - local.get $1 + call $~lib/number/I32#toString + local.set $0 + global.get $~lib/memory/__stack_pointer local.get $0 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s + i32.store offset=12 + i32.const 17888 + local.get $0 + call $~lib/string/String#concat + i32.const 20960 + i32.const 332 + i32.const 7 + call $~lib/builtins/abort + unreachable end - i32.add - br $folding-inner3 + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable end global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 2 - return + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s + i64.store + br $folding-inner6 end global.get $~lib/memory/__stack_pointer - i32.const 19552 + local.get $6 i32.store - local.get $0 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - i32.const 19552 - local.get $0 - call $~lib/string/String#concat - i32.const 20368 - i32.const 73 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - block $__inlined_func$assembly/program-build/immBytes$2175 (result i32) global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $0 - i32.const 0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$2175 - drop - local.get $0 - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=4 + i64.store offset=8 + br $folding-inner6 end - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u offset=1 - i32.const 1 - i32.add - local.tee $0 - i32.const 255 - i32.and - i32.const 1 - i32.add - block $__inlined_func$assembly/program-build/immBytes$2181 (result i32) global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $1 - local.get $0 - i32.const 255 - i32.and - i32.const 1 - i32.add - local.tee $0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$2181 - drop - local.get $1 - local.get $0 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=4 + i64.store offset=8 + br $folding-inner5 end - i32.add - br $folding-inner3 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=16 + local.get $6 + local.get $3 + i32.const 12 + local.get $2 + i64.load32_u offset=4 + local.tee $4 + i32.wrap_i64 + local.get $4 + i64.const 13 + i64.ge_u + select + call $~lib/staticarray/StaticArray#__get + i64.store offset=8 end global.get $~lib/memory/__stack_pointer - local.get $1 + local.get $6 i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - i32.const 1 - i32.add + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $6 + local.get $2 + i64.load32_s offset=8 + i64.store offset=16 end global.get $~lib/memory/__stack_pointer - i32.const 24 + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer + local.get $6 ) - (func $assembly/program-build/buildMask (param $0 i32) (result i32) + (func $assembly/api-internal/getOutputChunks (param $0 i32) (result i32) (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 32 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner0 + block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner0 + br_if $folding-inner1 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + i32.const 0 + i32.const 32 + memory.fill global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 + i32.const 0 + i32.const 2 + i32.const 51 + i32.const 21360 + call $~lib/rt/__newArray + local.tee $3 + i32.store global.get $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer local.get $0 - i32.store + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $3 + i32.load offset=8 + local.tee $5 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner0 + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.load offset=8 + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + i32.load offset=16 + local.set $8 + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.const 38 + call $~lib/rt/itcms/__new + local.tee $9 + i32.store global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 i32.const 0 i32.store - local.get $3 - i32.const 1073741820 + local.get $9 + i32.const 0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + i32.const 0 + i32.store offset=12 + local.get $8 + i32.const 268435455 i32.gt_u if i32.const 9200 - i32.const 9312 - i32.const 51 + i32.const 9152 + i32.const 70 i32.const 60 call $~lib/builtins/abort unreachable end global.get $~lib/memory/__stack_pointer - local.get $3 - i32.const 58 + i32.const 8 + local.get $8 + local.get $8 + i32.const 8 + i32.le_u + select + i32.const 2 + i32.shl + local.tee $10 + i32.const 1 call $~lib/rt/itcms/__new - local.tee $3 + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + local.get $9 + local.get $5 i32.store + local.get $9 + local.get $5 + i32.const 0 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $9 + i32.store offset=4 + local.get $9 + local.get $5 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $10 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + local.get $8 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $9 i32.store offset=4 loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length local.get $2 - i32.gt_s + local.get $8 + i32.lt_s if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 + local.get $7 local.get $2 - call $~lib/typedarray/Uint8Array#__get - local.set $1 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length - local.get $1 - i32.gt_s - if (result i32) + i32.const 12 + i32.mul + i32.add + local.tee $5 + i32.load offset=8 + i32.const 1 + i32.and + i32.eqz + if global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $4 + local.get $9 i32.store - local.get $4 + local.get $9 local.get $1 - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION + local.get $5 + i32.load + call $~lib/array/Array#__set + local.get $1 + i32.const 1 + i32.add + local.set $1 end - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 local.get $2 i32.const 1 - call $~lib/staticarray/StaticArray#__set + i32.add + local.set $2 + br $for-loop|0 + end + end + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store + local.get $9 + local.get $1 + call $~lib/array/Array#set:length + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=12 + i32.const 0 + local.set $1 + loop $for-loop|00 + global.get $~lib/memory/__stack_pointer + local.get $9 + i32.store offset=4 + local.get $9 + call $~lib/array/Array#get:length + local.get $4 + i32.gt_s + if global.get $~lib/memory/__stack_pointer - i32.const 1264 - i32.store - i32.const 1264 - local.get $1 - i32.load offset=4 - call $~lib/array/Array#__get - local.set $4 + local.get $9 + i32.store offset=4 + local.get $9 + local.get $4 + call $~lib/array/Array#__get + local.set $5 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store + i32.store offset=8 + global.get $~lib/memory/__stack_pointer local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $4 + i32.load offset=8 + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer local.get $2 - i32.const 1 - i32.add - local.tee $4 - i32.add - i32.ge_s - if (result i32) - local.get $1 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 1 - global.set $~argumentsLength - local.get $0 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/program-build/skipBytes - local.get $2 - i32.add - else - local.get $2 + local.get $5 + call $"~lib/map/Map#get" + local.tee $6 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $2 + i32.store offset=4 + local.get $2 + i32.load offset=4 + if + i32.const 0 + local.set $2 + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + local.get $7 + call $assembly/memory-page/RawPage#get:data + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $7 + i32.store offset=8 + local.get $7 + call $assembly/memory-page/RawPage#get:data + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $2 + call $~lib/typedarray/Uint8Array#__get + local.tee $7 + if + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=4 + local.tee $8 + i32.store offset=4 + local.get $8 + local.get $7 + call $~lib/array/Array#push + else + global.get $~lib/memory/__stack_pointer + call $assembly/api-internal/InitialChunk#constructor + local.tee $1 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + local.get $5 + i32.const 12 + i32.shl + local.get $2 + i32.add + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 1 + i32.const 0 + i32.const 27 + i32.const 0 + call $~lib/rt/__newArray + local.tee $8 + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.load offset=12 + i32.eqz + if + local.get $8 + i32.const 1 + i32.const 0 + i32.const 1 + call $~lib/array/ensureCapacity + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.const 1 + i32.store offset=12 + end + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + i32.load offset=4 + local.get $7 + i32.store8 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + local.get $1 + local.get $8 + i32.store offset=4 + local.get $1 + local.get $8 + i32.const 0 + call $~lib/rt/itcms/__link + end + else + local.get $1 + if + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $3 + local.get $1 + call $~lib/array/Array#push + i32.const 0 + local.set $1 + end + end + local.get $2 + i32.const 1 + i32.add + local.set $2 + br $for-loop|1 + end + end end + local.get $4 i32.const 1 i32.add - local.set $2 - br $for-loop|0 + local.set $4 + br $for-loop|00 end end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 20448 - call $~lib/rt/__newArray - local.tee $4 - i32.store offset=12 - i32.const 0 - local.set $0 - loop $for-loop|1 + local.get $1 + if global.get $~lib/memory/__stack_pointer local.get $3 - i32.store - local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - i32.lt_s - if - i32.const 0 - local.set $2 - local.get $0 - local.set $1 - loop $for-loop|3 - local.get $1 - local.get $0 - i32.const 8 - i32.add - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $2 - i32.const 255 - i32.and - i32.const 1 - i32.shr_u - local.tee $2 - i32.const 128 - i32.or - local.get $2 - local.get $1 - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - i32.lt_s - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $1 - call $~lib/staticarray/StaticArray#__get - else - i32.const 0 - end - select - local.set $2 - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|3 - end - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $2 - call $~lib/array/Array#push - local.get $0 - i32.const 8 - i32.add - local.set $0 - br $for-loop|1 - end + local.get $1 + call $~lib/array/Array#push end global.get $~lib/memory/__stack_pointer - i32.const 16 + i32.const 32 i32.add global.set $~lib/memory/__stack_pointer - local.get $4 + local.get $3 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $assembly/codec/encodeVarU32 (param $0 i64) (result i32) - (local $1 i32) + (func $assembly/api-internal/executeProgram (param $0 i32) (param $1 i32) (result i32) (local $2 i32) (local $3 i32) - (local $4 i64) + (local $4 i32) (local $5 i32) - (local $6 i64) + (local $6 i32) + (local $7 i32) + (local $8 i32) + (local $9 i32) + (local $10 i32) + (local $11 i32) + (local $12 i32) + (local $13 i32) global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 108 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner2 - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner2 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - local.get $0 - i64.eqz - if - i32.const 1 - call $~lib/typedarray/Uint8Array#constructor - local.set $3 - br $folding-inner1 - end - local.get $0 - i64.const 72057594037927936 - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - i32.const 9 - call $~lib/typedarray/Uint8Array#constructor - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.const 255 - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 108 + memory.fill + i32.const 1 + local.set $2 + loop $for-loop|0 + block $for-break0 local.get $2 - i32.load - local.tee $3 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/dataview/DataView#constructor@varargs$38 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 + i32.eqz + if + local.get $1 + if global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 + local.get $0 + i32.store offset=12 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - local.set $5 + i32.const 17824 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store + local.get $2 + call $~lib/staticarray/StaticArray#join + local.tee $2 + i32.store offset=16 global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 20528 i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 + local.get $2 + i32.store offset=8 + i32.const 20532 + local.get $2 + i32.store + i32.const 20528 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + i32.const 20528 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 0 + i32.const 15504 i32.store offset=8 + i32.const 20528 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $2 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 59 - call $~lib/rt/itcms/__new - local.tee $1 + local.get $2 i32.store + local.get $2 + call $~lib/console/console.log + end + local.get $1 + if global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store - local.get $1 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=4 + local.get $0 + i32.store offset=24 global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=8 + local.get $0 + i32.load offset=4 + local.tee $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 20592 + i32.store offset=20 + local.get $3 + i32.const 20592 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 17824 + i32.store offset=8 local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - local.get $5 - i32.lt_u - local.get $5 - i32.const 1073741820 - i32.gt_u - i32.or - if - i32.const 9200 - i32.const 20480 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end + call $~lib/array/Array<~lib/string/String>#join + local.tee $2 + i32.store offset=28 global.get $~lib/memory/__stack_pointer - local.get $1 + i32.const 20560 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $2 i32.store offset=8 - local.get $1 - local.get $3 + i32.const 20564 + local.get $2 i32.store - local.get $1 - local.get $3 - i32.const 0 + i32.const 20560 + local.get $2 + i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $3 + i32.const 20560 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $1 + i32.const 15504 + i32.store offset=8 + i32.const 20560 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 20624 i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $0 + i32.load offset=20 + call $~lib/number/I32#toString + local.set $1 + global.get $~lib/memory/__stack_pointer local.get $1 - local.get $5 i32.store offset=8 + i32.const 20624 + local.get $1 + call $~lib/string/String#concat + local.set $1 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer local.get $1 - br $__inlined_func$~lib/dataview/DataView#constructor@varargs$38 + i32.store + local.get $1 + call $~lib/console/console.log end - br $folding-inner2 + br $for-break0 end - local.tee $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner2 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer + if + global.get $~lib/memory/__stack_pointer + i32.const 20688 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $0 + i32.load offset=16 + i32.const 10 + call $~lib/util/number/utoa32 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + i32.const 20688 + local.get $2 + call $~lib/string/String#concat + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/console/console.log + end local.get $1 - i32.store + if + global.get $~lib/memory/__stack_pointer + i32.const 20720 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $2 + i32.store offset=12 + local.get $2 + call $assembly/gas/GasCounter#get@override + call $~lib/util/number/itoa64 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + i32.const 20720 + local.get $2 + call $~lib/string/String#concat + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/console/console.log + end local.get $1 - i32.load offset=8 - i32.const 9 - i32.lt_s if - i32.const 1504 - i32.const 20480 - i32.const 174 - i32.const 7 - call $~lib/builtins/abort - unreachable + global.get $~lib/memory/__stack_pointer + i32.const 20752 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $0 + i32.load offset=20 + call $~lib/number/I32#toString + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + i32.const 20752 + local.get $2 + call $~lib/string/String#concat + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/console/console.log end - global.get $~lib/memory/__stack_pointer local.get $1 - i32.store + if + global.get $~lib/memory/__stack_pointer + i32.const 20432 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 17824 + i32.store offset=20 + local.get $2 + call $~lib/staticarray/StaticArray#join + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + i32.const 20432 + local.get $2 + call $~lib/string/String#concat + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/console/console.log + end local.get $1 - i32.load offset=4 - local.get $0 - i64.store offset=1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i64.const 562949953421312 - local.set $4 - i32.const 7 - local.set $1 - loop $for-loop|0 + if + global.get $~lib/memory/__stack_pointer + i32.const 20432 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $2 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + i32.const 20800 + i32.store offset=32 + local.get $2 + i32.const 20800 + call $~lib/staticarray/StaticArray#map<~lib/string/String> + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 17824 + i32.store offset=20 + local.get $2 + call $~lib/array/Array<~lib/string/String>#join + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + i32.const 20432 + local.get $2 + call $~lib/string/String#concat + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/console/console.log + end local.get $1 - i32.const 0 - i32.ge_s if + global.get $~lib/memory/__stack_pointer local.get $0 - local.get $4 - i64.ge_u - if + i32.store + local.get $0 + i32.load offset=16 + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load + local.tee $3 + i32.store + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.gt_u + if (result i32) global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $3 - i32.store offset=16 - i32.const 256 - i32.const 1 - i32.const 8 - local.get $1 - i32.sub - local.tee $2 - i32.shl - i32.const 0 - local.get $2 - i32.const 32 - i32.lt_u - select - i32.sub - i64.extend_i32_s local.get $0 - i32.const 1 - local.get $1 - i32.const 3 - i32.shl + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load local.tee $2 - i32.shl - i32.const 0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer local.get $2 - i32.const 32 - i32.lt_u - select - i64.extend_i32_s - local.tee $4 - i64.div_u - i64.add - local.set $6 + i32.load + local.tee $2 + i32.store global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $0 i32.store offset=4 - local.get $3 - i32.const 0 - local.get $6 - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set + local.get $2 local.get $0 - local.get $4 - i64.rem_u - local.set $0 - i32.const 1 - local.set $2 - loop $for-loop|1 - local.get $2 - local.get $1 - i32.const 1 - i32.add - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $2 - local.get $0 - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $0 - i64.const 8 - i64.shr_u - local.set $0 - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end - end - br $folding-inner1 + i32.load offset=16 + call $~lib/typedarray/Uint8Array#__get + else + i32.const 0 end - local.get $4 - i64.const 7 - i64.shr_u - local.set $4 - local.get $1 - i32.const 1 - i32.sub - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20544 - i32.store offset=4 - local.get $0 - i32.const 10 - call $~lib/util/number/utoa64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - i32.const 20544 - local.get $1 - call $~lib/string/String#concat - i32.const 17408 - i32.const 160 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api/fillRegisters (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -8 - i32.and - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length - local.get $3 - i32.ne - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - call $~lib/array/Array#get:length - call $~lib/number/I32#toString - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - call $~lib/number/I32#toString - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 20768 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - i32.const 20772 - local.get $0 - i32.store - i32.const 20768 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 20768 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - i32.const 20780 - local.get $1 - i32.store - i32.const 20768 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 20768 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15424 - i32.store offset=12 - i32.const 20768 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 20816 - i32.const 166 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.lt_s - if - i64.const 0 - local.set $4 - i32.const 0 - local.set $3 - loop $for-loop|1 - local.get $3 - i32.const 8 - i32.lt_u - if + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $1 + global.get $assembly/instructions/INSTRUCTIONS + local.tee $3 i32.store - local.get $4 - local.get $1 local.get $2 - i32.const 3 - i32.shl - local.get $3 - i32.add - call $~lib/array/Array#__get - i64.extend_i32_u local.get $3 - i32.const 3 - i32.shl + call $~lib/array/Array#get:length i32.const 255 i32.and - i64.extend_i32_u - i64.shl - i64.or + i32.ge_u + if (result i32) + global.get $assembly/instructions/MISSING_INSTRUCTION + else + global.get $~lib/memory/__stack_pointer + global.get $assembly/instructions/INSTRUCTIONS + local.tee $3 + i32.store + local.get $3 + local.get $2 + call $~lib/array/Array#__get + end + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load offset=4 + local.tee $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $4 + local.get $0 + i32.load offset=16 + call $assembly/program/Mask#skipBytesToNextInstruction local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load + local.tee $5 + i32.store offset=40 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=44 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.const 255 + i32.and + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $2 + i32.store offset=48 + global.get $~lib/memory/__stack_pointer + i32.const 20912 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + i32.const 20916 + local.get $5 + i32.store + i32.const 20912 + local.get $5 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 20912 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + i32.const 20924 + local.get $2 + i32.store + i32.const 20912 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 20912 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store offset=8 + i32.const 20912 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/console/console.log + global.get $~lib/memory/__stack_pointer local.get $3 + i32.load offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load + local.tee $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.load + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $0 + i32.load offset=16 i32.const 1 i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $2 - local.get $4 - call $~lib/staticarray/StaticArray#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $assembly/program/liftBytes - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/program/deblob - local.tee $7 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 13 - call $~lib/staticarray/StaticArray#constructor - local.tee $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $5 - local.get $1 - call $assembly/api/fillRegisters - global.get $~lib/memory/__stack_pointer - call $assembly/memory/MemoryBuilder#constructor - local.tee $8 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=24 - block $__inlined_func$assembly/api/readPages$43 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 20880 - call $~lib/rt/__newArray - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - call $assembly/codec/Decoder#constructor - local.tee $2 - i32.store offset=8 - loop $while-continue|0 + local.set $6 + i32.const 1 + global.set $~argumentsLength + local.get $5 + local.get $6 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.set $5 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $6 i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#isExhausted - i32.eqz + local.get $5 + local.get $4 + local.get $6 + call $assembly/program/resolveArguments + local.tee $8 + i32.store offset=52 + local.get $8 if global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer + local.get $8 + i64.load + call $~lib/util/number/itoa64 + local.tee $2 + i32.store offset=56 global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner00 + local.get $8 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + local.get $8 + i32.load offset=32 + local.tee $3 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 48 - call $~lib/rt/itcms/__new - local.tee $9 - i32.store + local.get $3 + i32.load + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $3 + i32.store offset=60 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $8 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $9 - call $~lib/object/Object#constructor + local.get $8 + i64.load + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $4 + i32.store offset=64 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i64.load offset=8 + call $~lib/util/number/itoa64 + local.tee $5 + i32.store offset=68 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.load offset=32 + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $6 + i32.store offset=72 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i64.load offset=8 + i32.const 16 + call $~lib/util/number/utoa64 local.tee $9 - i32.store + i32.store offset=76 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $8 i32.store offset=4 - local.get $9 - i32.const 0 - i32.store global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $8 + i64.load offset=16 + call $~lib/util/number/itoa64 + local.tee $10 + i32.store offset=80 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.load offset=32 + local.tee $7 i32.store offset=4 - local.get $9 - i32.const 0 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.load offset=8 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $7 + i32.store offset=84 + global.get $~lib/memory/__stack_pointer + local.get $8 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $8 + i64.load offset=16 + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $11 + i32.store offset=88 + global.get $~lib/memory/__stack_pointer + local.get $8 i32.store offset=4 - local.get $9 - i32.const 0 + global.get $~lib/memory/__stack_pointer + local.get $8 + i64.load offset=24 + call $~lib/util/number/itoa64 + local.tee $12 + i32.store offset=92 + global.get $~lib/memory/__stack_pointer + local.get $8 i32.store offset=8 global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 + local.get $8 + i32.load offset=32 + local.tee $13 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $13 + i32.load offset=12 + i32.const 10 + call $~lib/util/number/utoa32 + local.tee $13 + i32.store offset=96 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i64.load offset=24 + i32.const 16 + call $~lib/util/number/utoa64 + local.tee $8 + i32.store offset=100 + global.get $~lib/memory/__stack_pointer + i32.const 21168 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $2 - i32.store offset=16 - local.get $9 + i32.store offset=8 + i32.const 21172 local.get $2 - call $assembly/codec/Decoder#u32 i32.store + i32.const 21168 + local.get $2 + i32.const 1 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $9 + i32.const 21168 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $9 - local.get $2 - call $assembly/codec/Decoder#u32 + local.get $3 + i32.store offset=8 + i32.const 21180 + local.get $3 + i32.store + i32.const 21168 + local.get $3 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 21168 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $9 + local.get $4 + i32.store offset=8 + i32.const 21188 + local.get $4 + i32.store + i32.const 21168 + local.get $4 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 21168 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $9 - i32.const 2 + local.get $5 + i32.store offset=8 + i32.const 21196 + local.get $5 + i32.store + i32.const 21168 + local.get $5 i32.const 1 - local.get $2 - call $assembly/codec/Decoder#u8 - select + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 21168 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 i32.store offset=8 + i32.const 21204 + local.get $6 + i32.store + i32.const 21168 + local.get $6 + i32.const 1 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $1 + i32.const 21168 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $9 - i32.store offset=16 - local.get $1 + i32.store offset=8 + i32.const 21212 local.get $9 - call $~lib/array/Array#push - br $while-continue|0 + i32.store + i32.const 21168 + local.get $9 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 21168 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + i32.const 21220 + local.get $10 + i32.store + i32.const 21168 + local.get $10 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 21168 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + i32.const 21228 + local.get $7 + i32.store + i32.const 21168 + local.get $7 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 21168 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=8 + i32.const 21236 + local.get $11 + i32.store + i32.const 21168 + local.get $11 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 21168 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $12 + i32.store offset=8 + i32.const 21244 + local.get $12 + i32.store + i32.const 21168 + local.get $12 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 21168 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $13 + i32.store offset=8 + i32.const 21252 + local.get $13 + i32.store + i32.const 21168 + local.get $13 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 21168 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=8 + i32.const 21260 + local.get $8 + i32.store + i32.const 21168 + local.get $8 + i32.const 1 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 21168 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 15504 + i32.store offset=8 + i32.const 21168 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/console/console.log end end global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - br $__inlined_func$assembly/api/readPages$43 + local.get $0 + i32.store + local.get $0 + call $assembly/interpreter/Interpreter#nextStep + local.set $2 + br $for-loop|0 end - br $folding-inner1 end - local.set $9 global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=24 global.get $~lib/memory/__stack_pointer - i32.const 24 + i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner1 + br_if $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill + i64.const 0 + i64.store global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 2 - i32.const 46 - i32.const 20912 - call $~lib/rt/__newArray - local.tee $10 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - call $assembly/codec/Decoder#constructor - local.tee $1 i32.store offset=8 - loop $while-continue|01 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - call $assembly/api-generic/InitialChunk#constructor - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - local.get $2 - local.get $1 - call $assembly/codec/Decoder#u32 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $assembly/codec/Decoder#u32 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $11 - call $assembly/codec/Decoder#bytes - local.tee $6 - i32.store offset=20 - i32.const 0 - local.set $3 - loop $for-loop|1 - local.get $3 - local.get $11 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - local.tee $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=16 - local.get $12 - local.get $6 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#push - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $10 - local.get $2 - call $~lib/array/Array#push - br $while-continue|01 - end - end global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer + i32.const 28 + i32.const 59 + call $~lib/rt/itcms/__new + local.tee $2 + i32.store global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $8 - local.get $9 - local.get $10 - call $assembly/api-generic/buildMemory - local.tee $0 - i32.store offset=28 + local.get $2 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $7 + local.get $2 + call $~lib/object/Object#constructor + local.tee $2 i32.store global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $2 i32.store offset=4 + local.get $2 + i32.const -1 + i32.store global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $7 - local.get $5 - local.get $0 - call $assembly/interpreter/Interpreter#constructor - local.tee $0 - i32.store offset=32 + local.get $2 + i32.store offset=4 + i32.const 0 + i32.const 3 + i32.const 56 + i32.const 21296 + call $~lib/rt/__newArray + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $3 + i32.store offset=8 + local.get $2 + local.get $3 i32.store offset=4 + local.get $2 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - local.get $4 - call $assembly/gas/GasCounter#set@override - local.get $0 - global.set $assembly/api/interpreter + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api/nextStep (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - if + local.get $2 + i32.store offset=4 + i32.const 0 + i32.const 2 + i32.const 51 + i32.const 21328 + call $~lib/rt/__newArray + local.set $3 global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store + local.get $3 + i32.store offset=8 + local.get $2 + local.get $3 + i32.store offset=12 + local.get $2 + local.get $3 + i32.const 0 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 43 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.get $0 + local.get $2 i32.store offset=4 + local.get $2 + i64.const 0 + i64.store offset=16 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - call $assembly/interpreter/Interpreter#nextStep + local.get $2 + i32.store offset=4 + local.get $2 + i32.const 0 + i32.store offset=24 global.get $~lib/memory/__stack_pointer i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $assembly/api/nSteps (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - if + local.get $2 + i32.store offset=104 global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 + local.get $2 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 51 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.get $1 + local.get $0 i32.store offset=4 - i32.const 1 - local.set $2 - loop $for-loop|0 - local.get $0 - local.get $3 - i32.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/interpreter/Interpreter#nextStep - local.tee $2 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end + local.get $2 + local.get $0 + i32.load offset=20 + i32.store global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer local.get $2 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $assembly/api/getProgramCounter (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=4 + local.tee $1 + i32.store offset=8 i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.eqz - if + global.set $~argumentsLength global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add + i32.const 4 + i32.sub global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 68 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/setNextProgramCounter (param $0 i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.eqz - if + i32.store global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add + local.get $1 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 76 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/getStatus (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.eqz - if global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store + local.get $1 + i32.const 20 + i32.sub + i32.load offset=16 + i32.const 3 + i32.shr_u + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.tee $3 + i32.const 0 + local.get $3 + i32.const 0 + i32.gt_s + select + local.tee $3 + i32.const 3 + i32.const 56 + i32.const 0 + call $~lib/rt/__newArray + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.load offset=4 + local.get $1 + local.get $3 + i32.const 3 + i32.shl + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - i32.const 1 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 84 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=20 - i32.const 255 - i32.and - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/getExitArg (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api/interpreter - i32.eqz - if global.get $~lib/memory/__stack_pointer - i32.const 12 + i32.const 4 i32.add global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $2 + local.get $4 + i32.store offset=4 + local.get $2 + local.get $4 i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 92 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=24 - local.tee $0 - i32.eqz - if - i32.const 0 - local.set $0 - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/api/getGasLeft (result i64) - (local $0 i32) - (local $1 i64) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter - i32.eqz - if + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - i64.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 100 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $0 - i32.store offset=8 - local.get $0 - call $assembly/gas/GasCounter#get@override - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api/setGasLeft (param $0 i64) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api/interpreter - if + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=16 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter + local.get $0 + i32.load offset=12 local.tee $1 + i32.store offset=4 + local.get $2 + local.get $1 + call $assembly/gas/GasCounter#get@override + i64.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $2 i32.store global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $1 + i32.store offset=8 local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 106 - i32.const 30 - call $~lib/builtins/abort - unreachable - end + call $assembly/api-internal/getOutputChunks + local.set $1 + global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 - global.get $~lib/memory/__stack_pointer + local.get $2 local.get $1 i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=12 - local.tee $1 - i32.store offset=8 + local.get $2 local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer local.get $0 - call $assembly/gas/GasCounter#set@override + i32.store offset=4 + local.get $2 + local.get $0 + i32.load offset=24 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $0 + i32.store + local.get $0 + call $assembly/memory/Memory#free + global.get $~lib/memory/__stack_pointer + i32.const 108 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable ) - (func $assembly/api/getRegisters (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i64) - (local $3 i32) - (local $4 i32) + (func $assembly/api-utils/runProgram (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) (param $4 i32) (result i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + (local $8 i32) global.get $~lib/memory/__stack_pointer i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 104 - call $~lib/typedarray/Uint8Array#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - i32.const 1 - global.set $~argumentsLength - local.get $3 - call $~lib/typedarray/Uint8Array#fill@varargs - local.tee $4 - i32.store offset=4 - global.get $assembly/api/interpreter - i32.eqz - if + block $folding-inner0 global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 i32.const 20 - i32.add + memory.fill + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=16 + local.tee $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=20 + local.tee $7 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=24 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 117 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.store offset=12 - loop $for-loop|0 + i32.const 60 + call $~lib/rt/itcms/__new + local.tee $8 + i32.store global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=8 + local.get $8 + local.get $5 i32.store offset=16 + local.get $8 + local.get $5 + i32.const 0 + call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=4 - local.tee $0 + local.get $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $8 + local.get $7 + i32.store offset=20 + local.get $8 + local.get $7 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $8 + local.get $0 + i32.store offset=24 + local.get $8 + local.get $0 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i32.const 0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $8 + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $8 i32.store + local.get $8 local.get $1 - local.get $0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + local.get $8 + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store + global.get $~lib/memory/__stack_pointer i32.const 20 i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - local.set $2 - i32.const 0 - local.set $0 - loop $for-loop|1 - local.get $0 - i32.const 8 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $1 - i32.const 3 - i32.shl - local.get $0 - i32.add - local.get $2 - i64.const 255 - i64.and - i32.wrap_i64 - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i64.const 8 - i64.shr_u - local.set $2 - local.get $0 - i32.const 1 - i32.add - local.set $0 - br $for-loop|1 - end - end - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/api/getPageDump (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $assembly/api/interpreter - i32.eqz - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 20816 - i32.const 142 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.tee $1 - i32.store - block $__inlined_func$assembly/memory/Memory#pageDump$2440 - local.get $1 - local.get $0 - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - local.set $0 - br $__inlined_func$assembly/memory/Memory#pageDump$2440 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.tee $1 - i32.store offset=8 - local.get $1 - local.get $0 - call $"~lib/map/Map#get" - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - call $assembly/memory-page/RawPage#get:data - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - end - local.get $0 - i32.store offset=16 - local.get $0 - i32.eqz - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.load offset=16 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.load offset=24 + local.tee $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.load offset=20 + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $2 + local.get $5 + call $assembly/interpreter/Interpreter#constructor + local.tee $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $4 + i32.store8 offset=32 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $0 + local.get $8 + i32.load + i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=12 + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $8 + i32.store offset=4 + local.get $2 + local.get $8 + i64.load offset=8 + call $assembly/gas/GasCounter#set@override + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $3 + call $assembly/api-internal/executeProgram + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + return end - i32.const 4096 - call $~lib/typedarray/Uint8Array#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store + i32.const 54560 + i32.const 54608 i32.const 1 - global.set $~argumentsLength - local.get $0 - call $~lib/typedarray/Uint8Array#fill@varargs - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer + i32.const 1 + call $~lib/builtins/abort + unreachable ) (func $~lib/object/Object#constructor (param $0 i32) (result i32) global.get $~lib/memory/__stack_pointer @@ -34913,11 +36115,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -34950,11 +36152,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -35011,11 +36213,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -35053,11 +36255,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -35100,11 +36302,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -35121,8 +36323,8 @@ i32.gt_s i32.or if - i32.const 15632 - i32.const 15760 + i32.const 15888 + i32.const 16016 i32.const 350 i32.const 5 call $~lib/builtins/abort @@ -35135,7 +36337,7 @@ i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - i32.const 15824 + i32.const 16080 return end local.get $1 @@ -35243,7 +36445,7 @@ i32.and i32.const 2 i32.shl - i32.const 16256 + i32.const 16512 i32.add i32.load i32.store @@ -35263,14 +36465,14 @@ i32.wrap_i64 i32.const 6 i32.shl - i32.const 16256 + i32.const 16512 i32.add i32.load16_u i32.store16 end else global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2258 (result i32) + block $__inlined_func$~lib/util/number/ulog_base$2322 (result i32) local.get $0 i64.extend_i32_u local.set $4 @@ -35291,7 +36493,7 @@ i32.div_u i32.const 1 i32.add - br $__inlined_func$~lib/util/number/ulog_base$2258 + br $__inlined_func$~lib/util/number/ulog_base$2322 end local.get $1 i64.extend_i32_s @@ -35360,50 +36562,6 @@ global.set $~lib/memory/__stack_pointer local.get $2 ) - (func $~lib/staticarray/StaticArray#constructor (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i32.const 134217727 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 3 - i32.shl - i32.const 14 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) (func $~lib/util/number/utoa64 (param $0 i64) (param $1 i32) (result i32) (local $2 i64) (local $3 i32) @@ -35415,11 +36573,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -35436,8 +36594,8 @@ i32.gt_s i32.or if - i32.const 15632 - i32.const 15760 + i32.const 15888 + i32.const 16016 i32.const 401 i32.const 5 call $~lib/builtins/abort @@ -35450,7 +36608,7 @@ i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - i32.const 15824 + i32.const 16080 return end local.get $1 @@ -35626,7 +36784,7 @@ i32.and i32.const 2 i32.shl - i32.const 16256 + i32.const 16512 i32.add i32.load i32.store @@ -35646,14 +36804,14 @@ i32.wrap_i64 i32.const 6 i32.shl - i32.const 16256 + i32.const 16512 i32.add i32.load16_u i32.store16 end else global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2264 (result i32) + block $__inlined_func$~lib/util/number/ulog_base$2327 (result i32) local.get $0 local.set $2 local.get $1 @@ -35673,7 +36831,7 @@ i32.div_u i32.const 1 i32.add - br $__inlined_func$~lib/util/number/ulog_base$2264 + br $__inlined_func$~lib/util/number/ulog_base$2327 end local.get $1 i64.extend_i32_s @@ -35741,6 +36899,50 @@ global.set $~lib/memory/__stack_pointer local.get $3 ) + (func $~lib/staticarray/StaticArray#constructor (param $0 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + local.get $0 + i32.const 134217727 + i32.gt_u + if + i32.const 9200 + i32.const 9312 + i32.const 51 + i32.const 60 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.const 3 + i32.shl + i32.const 14 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) (func $~lib/util/number/itoa64 (param $0 i64) (result i32) (local $1 i32) (local $2 i32) @@ -35751,11 +36953,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -35771,7 +36973,7 @@ i32.const 4 i32.add global.set $~lib/memory/__stack_pointer - i32.const 15824 + i32.const 16080 return end i64.const 0 @@ -35934,17 +37136,17 @@ global.set $~lib/memory/__stack_pointer local.get $2 ) - (func $export:assembly/index/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $export:assembly/api-internal/getAssembly (param $0 i32) (result i32) global.get $~lib/memory/__stack_pointer i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s if - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -35954,471 +37156,432 @@ local.get $0 i32.store local.get $0 - local.get $1 - local.get $2 - call $assembly/index/disassemble + call $assembly/api-internal/getAssembly global.get $~lib/memory/__stack_pointer i32.const 4 i32.add global.set $~lib/memory/__stack_pointer ) - (func $export:assembly/index/runProgram (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) + (local $1 i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 4 i32.sub global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer local.get $0 i32.store global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 24 + i32.const 20 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 24 + i32.const 20 memory.fill - block $__inlined_func$assembly/index/runProgram$2441 - local.get $2 - i32.eqz + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + call $assembly/program-build/buildMask + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i64.extend_i32_s + call $assembly/codec/encodeVarU32 + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + i32.const 2 + i32.add + local.get $2 + i32.add + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.get $2 + i32.add + call $~lib/typedarray/Uint8Array#constructor + local.tee $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.const 1 + i32.const 0 + call $~lib/typedarray/Uint8Array#__set + i32.const 2 + local.set $2 + loop $for-loop|0 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + local.get $4 + i32.gt_s if global.get $~lib/memory/__stack_pointer - call $assembly/api-generic/VmInput#constructor - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $2 - local.get $1 + local.get $6 i32.store - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + local.get $6 local.get $2 - i32.store offset=4 + local.get $5 + local.get $4 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set local.get $2 - i64.const 10000 - i64.store offset=8 + i32.const 1 + i32.add + local.set $2 + local.get $4 + i32.const 1 + i32.add + local.set $4 + br $for-loop|0 + end + end + loop $for-loop|1 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $1 + i32.gt_s + if global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 + local.get $6 + i32.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=8 - local.get $2 - local.get $0 i32.store offset=16 + local.get $6 local.get $2 local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/typedarray/Uint8Array#__get + call $~lib/typedarray/Uint8Array#__set local.get $2 i32.const 1 - i32.const 0 - call $assembly/api-generic/runVm - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 19248 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - local.get $0 - i32.load - call $~lib/number/I32#toString - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - i32.const 19248 + i32.add + local.set $2 local.get $1 - call $~lib/string/String#concat + i32.const 1 + i32.add local.set $1 + br $for-loop|1 + end + end + i32.const 0 + local.set $0 + loop $for-loop|2 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + call $~lib/array/Array#get:length + local.get $0 + i32.gt_s + if global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/console/console.log + local.get $6 + i32.store global.get $~lib/memory/__stack_pointer - i32.const 24 + local.get $3 + i32.store offset=16 + local.get $6 + local.get $2 + local.get $3 + local.get $0 + call $~lib/array/Array#__get + call $~lib/typedarray/Uint8Array#__set + local.get $2 + i32.const 1 i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$assembly/index/runProgram$2441 - end - local.get $2 - i32.const 1 - i32.eq - if - i32.const 20224 - i32.const 20304 - i32.const 57 - i32.const 5 - call $~lib/builtins/abort - unreachable + local.set $2 + local.get $0 + i32.const 1 + i32.add + local.set $0 + br $for-loop|2 end - global.get $~lib/memory/__stack_pointer - i32.const 18608 - i32.store offset=4 - local.get $2 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 18608 - local.get $0 - call $~lib/string/String#concat - i32.const 20304 - i32.const 60 - i32.const 3 - call $~lib/builtins/abort - unreachable end global.get $~lib/memory/__stack_pointer - i32.const 8 + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer - local.get $0 + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $export:assembly/api-generic/runVm@varargs (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (func $export:assembly/api-debugger/resetJAM@varargs (param $0 i32) (param $1 f64) (param $2 i64) (param $3 i32) (param $4 i32) global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner0 + block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner0 + br_if $folding-inner1 global.get $~lib/memory/__stack_pointer local.get $0 i32.store global.get $~lib/memory/__stack_pointer - i32.const 4 + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner0 + br_if $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable + i64.const 0 + i64.store + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 4 + i32.sub + br_table $0of1 $1of1 $outOfRange end - i32.const 0 - local.set $1 + unreachable end i32.const 0 - local.set $2 + local.set $4 end global.get $~lib/memory/__stack_pointer local.get $0 i32.store - local.get $0 - local.get $1 - local.get $2 - call $assembly/api-generic/runVm global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add + i32.const 32 + i32.sub global.set $~lib/memory/__stack_pointer - return - end - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api-generic/getAssembly (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/api-generic/getAssembly - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner0 + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $4 + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + call $assembly/program/liftBytes + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $assembly/program/extractCodeAndMetadata + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/program/liftBytes + end + local.tee $0 + i32.store offset=12 global.get $~lib/memory/__stack_pointer local.get $0 i32.store global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - br_if $folding-inner0 + local.get $3 + i32.store offset=8 + local.get $3 + call $assembly/program/liftBytes + local.set $3 global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill + local.get $3 + i32.store offset=4 + local.get $0 + local.get $3 + call $assembly/spi/decodeSpi + local.tee $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=16 + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=24 + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=20 + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $4 + local.get $0 + call $assembly/interpreter/Interpreter#constructor + local.tee $0 + i32.store offset=24 global.get $~lib/memory/__stack_pointer local.get $0 i32.store local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $2 + local.get $1 + i32.trunc_sat_f64_u + i32.store offset=28 global.get $~lib/memory/__stack_pointer local.get $0 - i32.store + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 - call $assembly/program-build/buildMask + i32.load offset=12 local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i64.extend_i32_s - call $assembly/codec/encodeVarU32 - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - i32.const 2 - i32.add - local.get $2 - i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $3 i32.store local.get $3 - call $~lib/array/Array#get:length local.get $2 - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set - i32.const 2 - local.set $2 - loop $for-loop|0 + call $assembly/gas/GasCounter#set@override + global.get $assembly/api-debugger/interpreter + if global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - local.get $4 - i32.gt_s + global.get $assembly/api-debugger/interpreter + local.tee $3 + i32.store offset=28 + local.get $3 + i32.eqz if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $6 - local.get $2 - local.get $5 - local.get $4 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|0 + i32.const 10512 + i32.const 19360 + i32.const 22 + i32.const 19 + call $~lib/builtins/abort + unreachable end - end - loop $for-loop|1 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - local.get $6 - local.get $2 - local.get $0 - local.get $1 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|1 - end - end - i32.const 0 - local.set $0 - loop $for-loop|2 + local.get $3 + i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $3 + i32.load offset=8 + local.tee $3 i32.store local.get $3 - call $~lib/array/Array#get:length - local.get $0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $6 - local.get $2 - local.get $3 - local.get $0 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - local.get $0 - i32.const 1 - i32.add - local.set $0 - br $for-loop|2 - end + call $assembly/memory/Memory#free end + local.get $0 + global.set $assembly/api-debugger/interpreter global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 32 i32.add global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 4 + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $6 return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $export:assembly/api/resetGeneric (param $0 i32) (param $1 i32) (param $2 i64) - (local $3 i32) + (func $export:assembly/api-debugger/resetGeneric@varargs (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i32) (local $4 i32) (local $5 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner0 + block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner0 + br_if $folding-inner1 global.get $~lib/memory/__stack_pointer local.get $0 i32.store @@ -36426,36 +37589,89 @@ local.get $1 i32.store offset=4 global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 8 i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill + br_if $folding-inner1 global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 3 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + i32.const 0 + local.set $3 + end global.get $~lib/memory/__stack_pointer local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 i32.store offset=4 - local.get $0 - call $assembly/program/liftBytes - local.set $0 + global.get $~lib/memory/__stack_pointer + i32.const 32 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 32 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $3 + if (result i32) + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + call $assembly/program/liftBytes + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + call $assembly/program/extractCodeAndMetadata + local.set $0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.load + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + call $assembly/program/liftBytes + end + local.tee $0 + i32.store offset=12 global.get $~lib/memory/__stack_pointer local.get $0 i32.store + global.get $~lib/memory/__stack_pointer local.get $0 call $assembly/program/deblob local.tee $3 - i32.store offset=8 + i32.store offset=16 global.get $~lib/memory/__stack_pointer i32.const 13 call $~lib/staticarray/StaticArray#constructor local.tee $0 - i32.store offset=12 + i32.store offset=20 global.get $~lib/memory/__stack_pointer local.get $0 i32.store @@ -36464,7 +37680,7 @@ i32.store offset=4 local.get $0 local.get $1 - call $assembly/api/fillRegisters + call $assembly/api-debugger/fillRegisters global.get $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer local.get $3 @@ -36479,9 +37695,9 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s - br_if $folding-inner0 + br_if $folding-inner1 global.get $~lib/memory/__stack_pointer i32.const 0 i32.const 20 @@ -36519,7 +37735,7 @@ i32.add global.set $~lib/memory/__stack_pointer local.get $0 - i32.store offset=16 + i32.store offset=24 global.get $~lib/memory/__stack_pointer local.get $0 i32.store offset=4 @@ -36531,10 +37747,41 @@ local.get $1 local.get $2 call $assembly/gas/GasCounter#set@override + global.get $assembly/api-debugger/interpreter + if + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $1 + i32.store offset=28 + local.get $1 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 38 + i32.const 19 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.load offset=8 + local.tee $1 + i32.store + local.get $1 + call $assembly/memory/Memory#free + end local.get $0 - global.set $assembly/api/interpreter + global.set $assembly/api-debugger/interpreter global.get $~lib/memory/__stack_pointer - i32.const 20 + i32.const 32 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 8 i32.add global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer @@ -36543,53 +37790,99 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $export:assembly/api/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) + (func $export:assembly/api-debugger/resetGenericWithMemory@varargs (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) (param $5 i32) global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21300 - i32.lt_s - if - i32.const 54096 - i32.const 54144 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + block $1of1 + block $0of1 + block $outOfRange + global.get $~argumentsLength + i32.const 5 + i32.sub + br_table $0of1 $1of1 $outOfRange + end + unreachable + end + i32.const 0 + local.set $5 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=12 + local.get $0 + local.get $1 + local.get $2 + local.get $3 + local.get $4 + local.get $5 + call $assembly/api-debugger/resetGenericWithMemory + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $0 - local.get $1 - local.get $2 - local.get $3 - local.get $4 - call $assembly/api/resetGenericWithMemory - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable ) - (func $export:assembly/api/setRegisters (param $0 i32) + (func $export:assembly/api-debugger/setRegisters (param $0 i32) (local $1 i32) (local $2 i32) global.get $~lib/memory/__stack_pointer @@ -36598,7 +37891,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -36609,17 +37902,17 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer i32.const 0 i32.const 20 memory.fill - global.get $assembly/api/interpreter + global.get $assembly/api-debugger/interpreter if global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter + global.get $assembly/api-debugger/interpreter local.tee $1 i32.store global.get $~lib/memory/__stack_pointer @@ -36627,8 +37920,8 @@ i32.eqz if i32.const 10512 - i32.const 20816 - i32.const 134 + i32.const 19360 + i32.const 160 i32.const 28 call $~lib/builtins/abort unreachable @@ -36648,7 +37941,7 @@ i32.store offset=12 local.get $1 local.get $0 - call $assembly/api/fillRegisters + call $assembly/api-debugger/fillRegisters end global.get $~lib/memory/__stack_pointer i32.const 20 @@ -36660,14 +37953,14 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort unreachable ) - (func $export:assembly/api/setMemory (param $0 i32) (param $1 i32) + (func $export:assembly/api-debugger/setMemory (param $0 i32) (param $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) @@ -36678,7 +37971,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -36689,7 +37982,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21300 + i32.const 21764 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -36698,10 +37991,10 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store offset=8 - global.get $assembly/api/interpreter + global.get $assembly/api-debugger/interpreter if global.get $~lib/memory/__stack_pointer - global.get $assembly/api/interpreter + global.get $assembly/api-debugger/interpreter local.tee $3 i32.store global.get $~lib/memory/__stack_pointer @@ -36709,8 +38002,8 @@ i32.eqz if i32.const 10512 - i32.const 20816 - i32.const 155 + i32.const 19360 + i32.const 181 i32.const 28 call $~lib/builtins/abort unreachable @@ -36770,8 +38063,183 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54096 - i32.const 54144 + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) + (func $export:assembly/api-utils/getGasCosts (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $assembly/api-utils/getGasCosts + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api-utils/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + call $assembly/api-utils/disassemble + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api-utils/prepareProgram (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=16 + local.get $0 + local.get $1 + local.get $2 + local.get $3 + local.get $4 + local.get $5 + local.get $6 + call $assembly/api-utils/prepareProgram + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $export:assembly/api-utils/runProgram@varargs (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) (param $4 i32) (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store + block $4of4 + block $3of4 + block $2of4 + block $1of4 + block $0of4 + block $outOfRange + global.get $~argumentsLength + i32.const 1 + i32.sub + br_table $0of4 $1of4 $2of4 $3of4 $4of4 $outOfRange + end + unreachable + end + i64.const 0 + local.set $1 + end + i32.const 0 + local.set $2 + end + i32.const 0 + local.set $3 + end + i32.const 0 + local.set $4 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + local.get $2 + local.get $3 + local.get $4 + call $assembly/api-utils/runProgram + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54560 + i32.const 54608 i32.const 1 i32.const 1 call $~lib/builtins/abort From 335b669e3e58de4b6f4b46acd1fbccba1cb0b11b Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Mon, 13 Oct 2025 21:30:38 +0200 Subject: [PATCH 05/21] added getPages --- assembly/api-debugger.ts | 10 +- build/debug.d.ts | 10 + build/debug.js | 5 + build/debug.wasm | Bin 197849 -> 198058 bytes build/debug.wasm.map | 2 +- build/debug.wat | 79 +++++++- build/release.d.ts | 10 + build/release.js | 5 + build/release.wasm | Bin 96928 -> 97107 bytes build/release.wasm.map | 2 +- build/release.wat | 420 +++++++++++++++++++++++---------------- 11 files changed, 364 insertions(+), 179 deletions(-) diff --git a/assembly/api-debugger.ts b/assembly/api-debugger.ts index 7001f56..e39ef54 100644 --- a/assembly/api-debugger.ts +++ b/assembly/api-debugger.ts @@ -3,7 +3,7 @@ import { Decoder } from "./codec"; import { Gas } from "./gas"; import { Interpreter, Status } from "./interpreter"; import { MemoryBuilder } from "./memory"; -import { Access, PAGE_SIZE } from "./memory-page"; +import { Access, Page, PAGE_SIZE } from "./memory-page"; import { deblob, extractCodeAndMetadata, liftBytes } from "./program"; import { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from "./registers"; import { decodeSpi } from "./spi"; @@ -134,6 +134,14 @@ export function setGasLeft(gas: i64): void { } } +export function getMemory(): Map { + if (interpreter === null) { + return new Map(); + } + const int = interpreter; + return int.memory.pages; +} + export function getRegisters(): Uint8Array { const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0); if (interpreter === null) { diff --git a/build/debug.d.ts b/build/debug.d.ts index 08a7a0a..e25b027 100644 --- a/build/debug.d.ts +++ b/build/debug.d.ts @@ -80,6 +80,11 @@ export declare function getGasLeft(): bigint; * @param gas `i64` */ export declare function setGasLeft(gas: bigint): void; +/** + * assembly/api-debugger/getMemory + * @returns `~lib/map/Map` + */ +export declare function getMemory(): __Internref18; /** * assembly/api-debugger/getRegisters * @returns `~lib/typedarray/Uint8Array` @@ -159,6 +164,11 @@ declare class __Internref30 extends Number { private __nominal30: symbol; private __nominal0: symbol; } +/** ~lib/map/Map */ +declare class __Internref18 extends Number { + private __nominal18: symbol; + private __nominal0: symbol; +} /** assembly/gas-costs/BlockGasCost */ declare interface __Record54 { /** @type `u32` */ diff --git a/build/debug.js b/build/debug.js index 383032a..8028789 100644 --- a/build/debug.js +++ b/build/debug.js @@ -96,6 +96,10 @@ async function instantiate(module, imports = {}) { gas = gas || 0n; exports.setGasLeft(gas); }, + getMemory() { + // assembly/api-debugger/getMemory() => ~lib/map/Map + return __liftInternref(exports.getMemory() >>> 0); + }, getRegisters() { // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); @@ -385,6 +389,7 @@ export const { getExitArg, getGasLeft, setGasLeft, + getMemory, getRegisters, setRegisters, getPageDump, diff --git a/build/debug.wasm b/build/debug.wasm index cd8496653757ac877fcb9302e2d60e02a701027c..22eeef61b1d68ebcaf0e61d9f48f56cf766717d3 100644 GIT binary patch delta 3769 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 RF8|S_A2Ci^@gu4d{|}V(qY(fA diff --git a/build/debug.wasm.map b/build/debug.wasm.map index 1694ca8..f8204e6 100644 --- a/build/debug.wasm.map +++ b/build/debug.wasm.map @@ -1 +1 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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+C,E,YAAA,GErElB,E,eFqEP,G,YAAZ,IACV,GAGE,EAAJ,E,gBAA8B,E,YAAA,GEoCC,E,eFpCT,G,YAAZ,IACN,EAAJ,E,gBAA+B,E,YAAA,G,YAAA,GErDA,E,eFqDT,G,YAAZ,IACN,EAAJ,E,gBAAkC,E,YAAA,GE3EH,E,eF2ET,G,YAAZ,IACN,EAAJ,E,gBAAqC,E,YAAA,G,YAAmB,I,YAAnB,G,YAAf,G,YAAZ,IACN,EAAJ,E,gBAAqC,E,YAAA,G,YAAkB,I,YAAlB,G,YAA0D,I,YAA1D,G,YAAf,G,YAAZ,IACN,EAAJ,E,AACsB,E,YAAA,G,AAAa,E,YAAA,G,YAAA,G,YAAJ,GAAT,G,AAAwC,E,YAAA,G,YAAA,G,YAAiB,E,YAAA,GAAjB,IAA2B,GAAvF,EACc,E,AAAmB,E,YAAJ,G,IAAf,GAAyC,G,AAAsB,E,YAAa,EAAb,IAA7E,E,AACkB,E,YAAA,G,YAAA,G,YAA4C,E,YAAA,GAA5C,GAAlB,E,GACgC,EAAnB,G,KACD,A,GAAiB,E,QAAS,EEhBV,E,6HFgB5B,G,GAC8B,K,AAAY,E,YAAA,G,YAAA,G,YAA0B,E,YAAA,GAAS,EAAT,C,MAA1B,G,YAAuC,E,AAAW,E,YAAA,G,YAA/E,G,KACT,EAAS,EAAT,CAAJ,E,AACc,A,GAChB,E,YAAA,GElE+B,E,WFkEpB,E,YAAA,G,YAAA,EEsBoB,E,WFtBO,E,YAAJ,GAAqB,EAArB,G,QAClC,E,YAAA,GEnE+B,E,WFmEpB,E,YAAA,G,YAAA,EEqBoB,E,WFrBO,E,YAAJ,GAAqB,EAArB,G,QAClC,E,YAAA,GEpE+B,E,WFoEpB,E,YAAA,G,YAAA,EEoBoB,E,WFpBO,E,YAAJ,GAAqB,EAArB,G,QAClC,E,YAAA,GErE+B,E,WFqEpB,E,YAAA,G,YAAA,EEmBoB,E,WFnBO,E,YAAJ,GAAqB,EAArB,G,wdAJ9B,K,AAQG,E,YAAA,GAAP,E,UAGa,G,KACf,E,YAAgB,E,YAAA,GAAhB,G,AACA,E,YAAmB,E,YAAA,G,YAAoB,E,MAApB,G,YAAnB,G,AACA,E,YAAY,E,YAAA,GAAZ,G,AACA,E,YAAa,E,YAAA,G,YAAA,GAAb,G,AACA,E,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","sourceRoot":"./debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, Page, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getMemory(): Map {\n if (interpreter === null) {\n return new Map();\n }\n const int = interpreter;\n return int.memory.pages;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/debug.wat b/build/debug.wat index 1cf935a..51b0126 100644 --- a/build/debug.wat +++ b/build/debug.wat @@ -695,6 +695,7 @@ (export "getExitArg" (func $assembly/api-debugger/getExitArg)) (export "getGasLeft" (func $assembly/api-debugger/getGasLeft)) (export "setGasLeft" (func $assembly/api-debugger/setGasLeft)) + (export "getMemory" (func $assembly/api-debugger/getMemory)) (export "getRegisters" (func $assembly/api-debugger/getRegisters)) (export "getPageDump" (func $assembly/api-debugger/getPageDump)) (export "InputKind.Generic" (global $assembly/api-utils/InputKind.Generic)) @@ -35263,7 +35264,7 @@ local.get $9 call $~lib/staticarray/StaticArray<~lib/string/String>#join i32.const 18336 - i32.const 192 + i32.const 200 i32.const 5 call $~lib/builtins/abort unreachable @@ -38803,6 +38804,74 @@ i32.add global.set $~lib/memory/__stack_pointer ) + (func $assembly/api-debugger/getMemory (result i32) + (local $0 i32) + (local $int i32) + (local $2 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.eq + if + i32.const 0 + call $"~lib/map/Map#constructor" + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $0 + i32.store + local.get $0 + if (result i32) + local.get $0 + else + i32.const 9488 + i32.const 18336 + i32.const 141 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + local.get $2 + call $assembly/interpreter/Interpreter#get:memory + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $2 + call $assembly/memory/Memory#get:pages + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) (func $assembly/api-debugger/getRegisters (result i32) (local $flat i32) (local $1 i32) @@ -38864,7 +38933,7 @@ else i32.const 9488 i32.const 18336 - i32.const 143 + i32.const 151 i32.const 28 call $~lib/builtins/abort unreachable @@ -38993,7 +39062,7 @@ else i32.const 9488 i32.const 18336 - i32.const 160 + i32.const 168 i32.const 28 call $~lib/builtins/abort unreachable @@ -39147,7 +39216,7 @@ else i32.const 9488 i32.const 18336 - i32.const 168 + i32.const 176 i32.const 28 call $~lib/builtins/abort unreachable @@ -39244,7 +39313,7 @@ else i32.const 9488 i32.const 18336 - i32.const 181 + i32.const 189 i32.const 28 call $~lib/builtins/abort unreachable diff --git a/build/release.d.ts b/build/release.d.ts index 08a7a0a..e25b027 100644 --- a/build/release.d.ts +++ b/build/release.d.ts @@ -80,6 +80,11 @@ export declare function getGasLeft(): bigint; * @param gas `i64` */ export declare function setGasLeft(gas: bigint): void; +/** + * assembly/api-debugger/getMemory + * @returns `~lib/map/Map` + */ +export declare function getMemory(): __Internref18; /** * assembly/api-debugger/getRegisters * @returns `~lib/typedarray/Uint8Array` @@ -159,6 +164,11 @@ declare class __Internref30 extends Number { private __nominal30: symbol; private __nominal0: symbol; } +/** ~lib/map/Map */ +declare class __Internref18 extends Number { + private __nominal18: symbol; + private __nominal0: symbol; +} /** assembly/gas-costs/BlockGasCost */ declare interface __Record54 { /** @type `u32` */ diff --git a/build/release.js b/build/release.js index 5556b95..2887c57 100644 --- a/build/release.js +++ b/build/release.js @@ -96,6 +96,10 @@ async function instantiate(module, imports = {}) { gas = gas || 0n; exports.setGasLeft(gas); }, + getMemory() { + // assembly/api-debugger/getMemory() => ~lib/map/Map + return __liftInternref(exports.getMemory() >>> 0); + }, getRegisters() { // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); @@ -385,6 +389,7 @@ export const { getExitArg, getGasLeft, setGasLeft, + getMemory, getRegisters, setRegisters, getPageDump, diff --git a/build/release.wasm b/build/release.wasm index 611743d556978750d7f8e7dd44de43f8b5202f4b..a15a2cc5756ee93e1146b9fc5adbb72d0f7315cc 100644 GIT binary patch delta 2098 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 diff --git a/build/release.wasm.map b/build/release.wasm.map index 288186d..2debc2e 100644 --- a/build/release.wasm.map +++ b/build/release.wasm.map @@ -1 +1 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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V,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDzCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAG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AAc,E,KAAA,G,IAAW,E,KLkBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTuIO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDS/IM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/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J,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EbyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GazDb,Gf+BK,E,6DexBH,E,KAAc,E,KbuDiB,E,EavDjB,G,EbuDuC,CAAlD,EAAK,EAAL,EavDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EatDM,G,EbsDgB,CAAlD,EAAK,EAAL,EatDoB,EAAzB,GfuBK,E,6DehBH,E,KAAc,E,Kb+CiB,E,Ea/CjB,G,Eb+CuC,CAAlD,EAAK,EAAL,Ea/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea9CM,G,Eb8CgB,CAAlD,EAAK,EAAL,Ea9CoB,EAAzB,GfeK,E,6DgB9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,Kd6EL,E,Ec7EK,G,Ed6EiB,CAAlD,EAAK,EAAL,Ec7EwB,E,IAAiC,EdwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,Ec7EwB,E,EdwEhB,GcvBN,CAjDT,EhB8CO,E,6DgBxCP,E,YAAS,G,IAAoC,E,KdkE9B,G,IclEuC,E,KAAS,E,KduE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EcvE4B,G,EduEN,CAAlD,EAAK,EAAL,EcvE+C,EA2C7C,CA3CT,EhBwCO,E,6DgBlCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdiE1B,E,EcjE0B,G,EdiEJ,CAAlD,EAAK,EAAL,E,EcjEyC,C,IAA4B,EAyCtD,G,EdwBa,E,EAAsB,CAAlD,EAAK,EAAL,EcjEyC,E,EAyC1B,GAAb,CdmBF,Cc5DP,EhBkCO,E,6DgB5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,Kd2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EcxBY,E,EdwBgB,E,Ec3DuC,G,Ed2DjB,CAAlD,EAAK,EAAL,E,Ec3DsD,CAmCpD,CdmBF,CctDP,EhB4BO,E,6DgBtBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdqDL,E,EcrDK,G,EdqDiB,CAAlD,EAAK,EAAL,EcrDwB,E,IAAmB,E,KAAS,E,KdqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EcrDwB,E,EdqDI,E,EcrDwB,G,EdqDF,CAAlD,EAAK,EAAL,EcrD2C,EAiCzC,CAjCT,EhBsBO,E,6DgBhBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,Kd+C1B,E,Ec/C0B,G,Ed+CJ,CAAlD,EAAK,EAAL,E,Ec/CyC,C,IAA4B,E,KAAS,E,Kd+ClD,E,EAAsB,CAAlD,EAAK,EAAL,Ec/CyC,E,Ed+Cb,E,Ec/CkD,G,Ed+C5B,CAAlD,EAAK,EAAL,E,Ec/CiE,CA+B/D,CdWF,Cc1CP,EhBgBO,E,6DgBVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdyCL,E,EczCK,G,EdyCiB,CAAlD,EAAK,EAAL,EczCwB,E,IAAmB,E,KAAS,E,KdyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EczCwB,E,EdyCI,E,EczCwB,G,EdyCF,CAAlD,EAAK,EAAL,EczC2C,EAazC,CAbT,EhBUO,E,6DgBJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdmC1B,E,EcnC0B,G,EdmCJ,CAAlD,EAAK,EAAL,E,EcnCyC,C,IAA4B,E,KAAS,E,KdmClD,E,EAAsB,CAAlD,EAAK,EAAL,EcnCyC,E,EdmCb,E,EcnCkD,G,EdmC5B,CAAlD,EAAK,EAAL,E,EcnCiE,CAW/D,CdmBF,Cc9BP,EhBIO,E,sDiB9CM,E,Yf6EsB,E,Ee7ER,G,Ef6E8B,CAAlD,EAAK,EAAL,Ee7EM,E,EAA2C,EfwEzC,G,EAAA,GexEF,CAAb,E,EACA,E,KAAc,E,Kf4EqB,E,Ee5ErB,G,Ef4E2C,CAAlD,EAAK,EAAL,Ee5EkB,GAAzB,EjB6CO,E,sDiBvCU,E,YfsEkB,E,EetEJ,G,EfsE0B,CAAlD,EAAK,EAAL,EetEM,E,EAA4C,EfiE1C,G,EAAA,GejEF,CAAb,E,EACA,E,KAAc,E,KfqEqB,E,EerErB,G,EfqE2C,CAAlD,EAAK,EAAL,EerEkB,GAAzB,EjBsCO,E,sDiBhCM,E,Yf+DsB,E,Ee/DR,G,Ef+D8B,CAAlD,EAAK,EAAL,Ee/DM,E,EAA2C,Ef0DzC,G,EAAA,Ge1DF,CAAb,E,EACA,E,KAAc,E,Kf8DqB,E,Ee9DrB,G,Ef8D2C,CAAlD,EAAK,EAAL,Ee9DkB,GAAzB,EjB+BO,E,sDiBzBU,E,YfwDkB,E,EexDJ,G,EfwD0B,CAAlD,EAAK,EAAL,EexDM,E,EAA4C,EfmD1C,G,EAAA,GenDF,CAAb,E,EACA,E,KAAc,E,KfuDqB,E,EevDrB,G,EfuD2C,CAAlD,EAAK,EAAL,EevDkB,GAAzB,EjBwBO,E,6DiBlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KfiDJ,E,EejDI,G,EfiDkB,CAAlD,EAAK,EAAL,EejDkB,E,IAAyB,E,KAAc,E,KfiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EejD6B,G,EfiDP,CAAlD,EAAK,EAAL,EejD2C,EAAzB,IAAzB,EjBkBO,E,6DiBZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kf2CR,E,Ee3CQ,G,Ef2Cc,CAAlD,EAAK,EAAL,Ee3CkB,E,IAAkC,E,KAAc,E,Kf2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ee3CsC,G,Ef2ChB,CAAlD,EAAK,EAAL,Ee3CgD,EAA9B,IAAzB,EjBYO,E,wDkB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhByEG,E,EgBzEH,G,EhByEyB,CAAlD,EAAK,EAAL,E,EgBzEO,CAAd,E,EACA,E,KAAc,E,KhBwEqB,E,EgBxErB,G,EhBwE2C,CAAlD,EAAK,EAAL,EgBxEgC,EAAS,EAAT,ChBmEhC,CgBnEP,ElByCO,E,wDkBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBiEG,E,EgBjEH,G,EhBiEyB,CAAlD,EAAK,EAAL,E,EgBjEO,CAAd,E,EACA,E,KAAc,E,KhBgEqB,E,EgBhErB,G,EhBgE2C,CAAlD,EAAK,EAAL,EgBhEgC,EAAU,EAAV,ChB2DhC,CgB3DP,ElBiCO,E,sDkB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KhByDX,E,EgBzDW,G,EhByDW,CAAlD,EAAK,EAAL,E,EgBzDqB,CAA5B,E,EACA,E,KAAc,E,KhBwDqB,E,EgBxDrB,G,EhBwD2C,CAAlD,EAAK,EAAL,EgBxDkB,E,EAAS,CAAT,CAAzB,ElByBO,E,sDkBnBW,E,KAAc,E,KhBkDG,E,EgBlDH,G,EhBkDyB,CAAlD,EAAK,EAAL,EgBlDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhBiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgBjD0C,EAAV,ChB4ChC,CgB5CP,ElBkBO,E,sDkBZW,E,KAAc,E,KhB2CG,E,EgB3CH,G,EhB2CyB,CAAlD,EAAK,EAAL,EgB3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhB0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgB1C2C,EAAX,ChBqChC,CgBrCP,ElBWO,E,sDkBLW,E,YhBoCiB,E,EgBpCH,G,EhBoCyB,CAAlD,EAAK,EAAL,EgBpCW,E,GAAJ,CAAd,E,EAC0B,E,KhB8BX,GgB9Bf,E,EACA,E,KAAc,E,KhBkCqB,E,EgBlCrB,G,EhBkC2C,CAAlD,EAAK,EAAL,EgBlCoC,E,EAAO,C,CAAX,CAAvC,ElBGO,E,6DkBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhB2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgB3BI,G,EhB2BkB,CAAlD,EAAK,EAAL,EgB3BkB,E,EAA0B,CAA1B,CAAzB,ElBJO,E,6DkBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBpBI,G,EhBoBkB,CAAlD,EAAK,EAAL,EgBpBkB,E,EAA2B,CAA3B,CAAzB,ElBXO,E,sDkBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBaG,E,EgBbH,G,EhBayB,CAAlD,EAAK,EAAL,EgBbO,EAAd,E,EACA,E,KAAc,E,KhBYqB,E,EgBZrB,G,EhBY2C,CAAlD,EAAK,EAAL,EgBZkB,E,EAAS,CAAT,CAAzB,ElBnBO,E,sDkByBW,E,KAAc,E,KhBMG,E,EgBNH,G,EhBMyB,CAAlD,EAAK,EAAL,EgBNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBAmC,CAAzB,CAAzB,ElB1BO,E,sDkBgCW,E,KAAc,E,KhBDG,E,EgBCH,G,EhBDyB,CAAlD,EAAK,EAAL,EgBCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBOoC,CAA1B,CAAzB,ElBjCO,E,sDkBuCW,E,YhBRiB,E,EgBQH,G,EhBRyB,CAAlD,EAAK,EAAL,EgBQW,E,GAAJ,CAAd,E,EAC4B,E,KhBdb,GgBcf,E,EACA,E,KAAc,E,KhBVqB,E,EgBUrB,G,EhBV2C,CAAlD,EAAK,EAAL,EgBUoC,E,EAAS,C,CAAb,CAAvC,ElBzCO,E,wDkB+CW,E,KAAc,E,KhBhBG,E,EgBgBH,G,EhBhByB,CAAlD,EAAK,EAAL,EgBgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBjBG,E,EgBiBH,G,EhBjByB,CAAlD,EAAK,EAAL,E,EgBiBO,CAAd,E,EACA,E,KAAc,E,KhBlBqB,E,EgBkBrB,G,EhBlB2C,CAAlD,EAAK,EAAL,EgBkBgC,EAAS,EAAT,ChBvBhC,CgBuBP,ElBjDO,E,wDkBuDW,E,KAAc,E,KhBxBG,E,EgBwBH,G,EhBxByB,CAAlD,EAAK,EAAL,EgBwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBzBG,E,EgByBH,G,EhBzByB,CAAlD,EAAK,EAAL,E,EgByBO,CAAd,E,EACA,E,KAAc,E,KhB1BqB,E,EgB0BrB,G,EhB1B2C,CAAlD,EAAK,EAAL,EgB0BgC,EAAU,EAAV,ChB/BhC,CgB+BP,ElBzDO,E,sDkB+DW,E,KAAc,E,KhBhCG,E,EgBgCH,G,EhBhCyB,CAAlD,EAAK,EAAL,EgBgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KhBjCd,E,EgBiCc,G,EhBjCQ,CAAlD,EAAK,EAAL,E,EgBiCwB,CAA/B,E,EACA,E,KAAc,E,KhBlCqB,E,EgBkCrB,G,EhBlC2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ByBuB,CAAlD,EAAK,EAAL,EiBzBa,E,EAAuC,EjBoB5C,G,EAAA,G,CiBpBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YjBkBe,E,EiBlBD,G,EjBkBuB,CAAlD,EAAK,EAAL,EiBlBa,E,EAAuC,EjBa5C,G,EAAA,G,CiBbC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YjBWe,E,EiBXD,G,EjBWuB,CAAlD,EAAK,EAAL,EiBXa,E,EAAuC,EjBM5C,G,EAAA,G,CiBNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YjBIe,E,EiBJD,G,EjBIuB,CAAlD,EAAK,EAAL,EiBJa,E,EAAuC,EjBD5C,G,EAAA,G,CiBCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBFjB,GiBEG,G,OACD,E,KAAV,E,+DAKa,E,YjBHe,E,EiBGD,G,EjBHuB,CAAlD,EAAK,EAAL,EiBGa,E,EAAuC,EjBR5C,G,EAAA,G,CiBQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EjBJQ,E,EiBIoB,G,EjBJE,CAAlD,EAAK,EAAL,EiBIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YjBVe,E,EiBUD,G,EjBVuB,CAAlD,EAAK,EAAL,EiBUa,E,EAAuC,EjBf5C,G,EAAA,G,CiBeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EjBXO,E,EiBWsB,G,EjBXA,CAAlD,EAAK,EAAL,EiBWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBjBe,E,EiBiBD,G,EjBjBuB,CAAlD,EAAK,EAAL,EiBiBa,E,EAAuC,EjBtB5C,G,EAAA,G,CiBsBC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA3B,E,EjBlBO,E,EiBkBoB,G,EjBlBE,CAAlD,EAAK,EAAL,E,EiBkB8B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBxBe,E,EiBwBD,G,EjBxBuB,CAAl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K,EAAL,EoBiOU,E,QAab,E,KAAa,E,KAAc,E,OpB9OI,E,EoB8OJ,G,EpB9O0B,CAAlD,EAAK,EAAL,EoB8OU,E,KACb,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAA2B,E,OpBrPhB,G,KoBsPX,E,KAA2B,E,OpBtPhB,G,QoByPX,E,KAAa,E,KAAc,E,OpBpPI,E,EoBoPJ,G,EpBpP0B,CAAlD,EAAK,EAAL,EoBoPU,E,KACb,E,KAAa,E,KAAc,E,OpBrPI,E,EoBqPJ,G,EpBrP0B,CAAlD,EAAK,EAAL,EoBqPU,E,KACb,E,KAAa,E,KAAc,E,OpBtPI,E,EoBsPJ,G,EpBtP0B,CAAlD,EAAK,EAAL,EoBsPU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBzMhB,G,QoB6MX,E,KAA2B,E,OpB7MhB,G,QoB2NX,E,KAAa,E,KAAc,E,OpBtNI,E,EoBsNJ,G,EpBtN0B,CAAlD,EAAK,EAAL,EoBsNU,E,KACb,E,KAA2B,E,OpB5NhB,G,QoByOX,E,KAAa,E,KAAc,E,OpBpOI,E,EoBoOJ,G,EpBpO0B,CAAlD,EAAK,EAAL,EoBoOU,E,KACb,E,KAAa,E,KAAc,E,OpBrOI,E,EoBqOJ,G,EpBrO0B,CAAlD,EAAK,EAAL,EoBqOU,E,MAbb,E,KAA2B,E,OpB7NhB,G,WoBuMJ,E,6CKnMoB,G,SACjB,E,wCnBkHkB,E,QAA9B,E,EACW,E,QAAX,E,6GbhII,EAAc,MAAd,CAAJ,EAA4E,I,iBAEvD,E,KAAJ,CAAgC,EAAhC,CAAjB,EACuD,EAA1C,E,OAIb,E,KAAc,E,oBACd,E,KAAiB,E,KACjB,E,KAAkB,E,KAClB,E,KAAe,E,iBayHC,EAAI,EAAJ,C,EACwB,EAAQ,EAAW,EAAX,CAAlC,CAAZ,E,GACyB,EAAnB,C,CAAN,E,EACY,E,KAAK,EAAY,E,GAA3B,E,KADF,GAF0B,E,GAAF,E,MAM1B,E,KAAc,EAAd,G,YmB3HsC,EAAxC,E,WACoB,GAAJ,G,IACE,E,KAAM,EAAN,GAAhB,E,EACa,E,mBAAiB,EAAjB,E,OAGT,E,sBAIS,E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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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V,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDzCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAG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AAc,E,KAAA,G,IAAW,E,KLkBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTuIO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDS/IM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/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J,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EbyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GazDb,Gf+BK,E,6DexBH,E,KAAc,E,KbuDiB,E,EavDjB,G,EbuDuC,CAAlD,EAAK,EAAL,EavDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EatDM,G,EbsDgB,CAAlD,EAAK,EAAL,EatDoB,EAAzB,GfuBK,E,6DehBH,E,KAAc,E,Kb+CiB,E,Ea/CjB,G,Eb+CuC,CAAlD,EAAK,EAAL,Ea/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea9CM,G,Eb8CgB,CAAlD,EAAK,EAAL,Ea9CoB,EAAzB,GfeK,E,6DgB9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,Kd6EL,E,Ec7EK,G,Ed6EiB,CAAlD,EAAK,EAAL,Ec7EwB,E,IAAiC,EdwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,Ec7EwB,E,EdwEhB,GcvBN,CAjDT,EhB8CO,E,6DgBxCP,E,YAAS,G,IAAoC,E,KdkE9B,G,IclEuC,E,KAAS,E,KduE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EcvE4B,G,EduEN,CAAlD,EAAK,EAAL,EcvE+C,EA2C7C,CA3CT,EhBwCO,E,6DgBlCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdiE1B,E,EcjE0B,G,EdiEJ,CAAlD,EAAK,EAAL,E,EcjEyC,C,IAA4B,EAyCtD,G,EdwBa,E,EAAsB,CAAlD,EAAK,EAAL,EcjEyC,E,EAyC1B,GAAb,CdmBF,Cc5DP,EhBkCO,E,6DgB5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,Kd2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EcxBY,E,EdwBgB,E,Ec3DuC,G,Ed2DjB,CAAlD,EAAK,EAAL,E,Ec3DsD,CAmCpD,CdmBF,CctDP,EhB4BO,E,6DgBtBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdqDL,E,EcrDK,G,EdqDiB,CAAlD,EAAK,EAAL,EcrDwB,E,IAAmB,E,KAAS,E,KdqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EcrDwB,E,EdqDI,E,EcrDwB,G,EdqDF,CAAlD,EAAK,EAAL,EcrD2C,EAiCzC,CAjCT,EhBsBO,E,6DgBhBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,Kd+C1B,E,Ec/C0B,G,Ed+CJ,CAAlD,EAAK,EAAL,E,Ec/CyC,C,IAA4B,E,KAAS,E,Kd+ClD,E,EAAsB,CAAlD,EAAK,EAAL,Ec/CyC,E,Ed+Cb,E,Ec/CkD,G,Ed+C5B,CAAlD,EAAK,EAAL,E,Ec/CiE,CA+B/D,CdWF,Cc1CP,EhBgBO,E,6DgBVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdyCL,E,EczCK,G,EdyCiB,CAAlD,EAAK,EAAL,EczCwB,E,IAAmB,E,KAAS,E,KdyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EczCwB,E,EdyCI,E,EczCwB,G,EdyCF,CAAlD,EAAK,EAAL,EczC2C,EAazC,CAbT,EhBUO,E,6DgBJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdmC1B,E,EcnC0B,G,EdmCJ,CAAlD,EAAK,EAAL,E,EcnCyC,C,IAA4B,E,KAAS,E,KdmClD,E,EAAsB,CAAlD,EAAK,EAAL,EcnCyC,E,EdmCb,E,EcnCkD,G,EdmC5B,CAAlD,EAAK,EAAL,E,EcnCiE,CAW/D,CdmBF,Cc9BP,EhBIO,E,sDiB9CM,E,Yf6EsB,E,Ee7ER,G,Ef6E8B,CAAlD,EAAK,EAAL,Ee7EM,E,EAA2C,EfwEzC,G,EAAA,GexEF,CAAb,E,EACA,E,KAAc,E,Kf4EqB,E,Ee5ErB,G,Ef4E2C,CAAlD,EAAK,EAAL,Ee5EkB,GAAzB,EjB6CO,E,sDiBvCU,E,YfsEkB,E,EetEJ,G,EfsE0B,CAAlD,EAAK,EAAL,EetEM,E,EAA4C,EfiE1C,G,EAAA,GejEF,CAAb,E,EACA,E,KAAc,E,KfqEqB,E,EerErB,G,EfqE2C,CAAlD,EAAK,EAAL,EerEkB,GAAzB,EjBsCO,E,sDiBhCM,E,Yf+DsB,E,Ee/DR,G,Ef+D8B,CAAlD,EAAK,EAAL,Ee/DM,E,EAA2C,Ef0DzC,G,EAAA,Ge1DF,CAAb,E,EACA,E,KAAc,E,Kf8DqB,E,Ee9DrB,G,Ef8D2C,CAAlD,EAAK,EAAL,Ee9DkB,GAAzB,EjB+BO,E,sDiBzBU,E,YfwDkB,E,EexDJ,G,EfwD0B,CAAlD,EAAK,EAAL,EexDM,E,EAA4C,EfmD1C,G,EAAA,GenDF,CAAb,E,EACA,E,KAAc,E,KfuDqB,E,EevDrB,G,EfuD2C,CAAlD,EAAK,EAAL,EevDkB,GAAzB,EjBwBO,E,6DiBlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KfiDJ,E,EejDI,G,EfiDkB,CAAlD,EAAK,EAAL,EejDkB,E,IAAyB,E,KAAc,E,KfiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EejD6B,G,EfiDP,CAAlD,EAAK,EAAL,EejD2C,EAAzB,IAAzB,EjBkBO,E,6DiBZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kf2CR,E,Ee3CQ,G,Ef2Cc,CAAlD,EAAK,EAAL,Ee3CkB,E,IAAkC,E,KAAc,E,Kf2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ee3CsC,G,Ef2ChB,CAAlD,EAAK,EAAL,Ee3CgD,EAA9B,IAAzB,EjBYO,E,wDkB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhByEG,E,EgBzEH,G,EhByEyB,CAAlD,EAAK,EAAL,E,EgBzEO,CAAd,E,EACA,E,KAAc,E,KhBwEqB,E,EgBxErB,G,EhBwE2C,CAAlD,EAAK,EAAL,EgBxEgC,EAAS,EAAT,ChBmEhC,CgBnEP,ElByCO,E,wDkBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBiEG,E,EgBjEH,G,EhBiEyB,CAAlD,EAAK,EAAL,E,EgBjEO,CAAd,E,EACA,E,KAAc,E,KhBgEqB,E,EgBhErB,G,EhBgE2C,CAAlD,EAAK,EAAL,EgBhEgC,EAAU,EAAV,ChB2DhC,CgB3DP,ElBiCO,E,sDkB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KhByDX,E,EgBzDW,G,EhByDW,CAAlD,EAAK,EAAL,E,EgBzDqB,CAA5B,E,EACA,E,KAAc,E,KhBwDqB,E,EgBxDrB,G,EhBwD2C,CAAlD,EAAK,EAAL,EgBxDkB,E,EAAS,CAAT,CAAzB,ElByBO,E,sDkBnBW,E,KAAc,E,KhBkDG,E,EgBlDH,G,EhBkDyB,CAAlD,EAAK,EAAL,EgBlDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhBiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgBjD0C,EAAV,ChB4ChC,CgB5CP,ElBkBO,E,sDkBZW,E,KAAc,E,KhB2CG,E,EgB3CH,G,EhB2CyB,CAAlD,EAAK,EAAL,EgB3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhB0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgB1C2C,EAAX,ChBqChC,CgBrCP,ElBWO,E,sDkBLW,E,YhBoCiB,E,EgBpCH,G,EhBoCyB,CAAlD,EAAK,EAAL,EgBpCW,E,GAAJ,CAAd,E,EAC0B,E,KhB8BX,GgB9Bf,E,EACA,E,KAAc,E,KhBkCqB,E,EgBlCrB,G,EhBkC2C,CAAlD,EAAK,EAAL,EgBlCoC,E,EAAO,C,CAAX,CAAvC,ElBGO,E,6DkBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhB2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgB3BI,G,EhB2BkB,CAAlD,EAAK,EAAL,EgB3BkB,E,EAA0B,CAA1B,CAAzB,ElBJO,E,6DkBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBpBI,G,EhBoBkB,CAAlD,EAAK,EAAL,EgBpBkB,E,EAA2B,CAA3B,CAAzB,ElBXO,E,sDkBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBaG,E,EgBbH,G,EhBayB,CAAlD,EAAK,EAAL,EgBbO,EAAd,E,EACA,E,KAAc,E,KhBYqB,E,EgBZrB,G,EhBY2C,CAAlD,EAAK,EAAL,EgBZkB,E,EAAS,CAAT,CAAzB,ElBnBO,E,sDkByBW,E,KAAc,E,KhBMG,E,EgBNH,G,EhBMyB,CAAlD,EAAK,EAAL,EgBNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBAmC,CAAzB,CAAzB,ElB1BO,E,sDkBgCW,E,KAAc,E,KhBDG,E,EgBCH,G,EhBDyB,CAAlD,EAAK,EAAL,EgBCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBOoC,CAA1B,CAAzB,ElBjCO,E,sDkBuCW,E,YhBRiB,E,EgBQH,G,EhBRyB,CAAlD,EAAK,EAAL,EgBQW,E,GAAJ,CAAd,E,EAC4B,E,KhBdb,GgBcf,E,EACA,E,KAAc,E,KhBVqB,E,EgBUrB,G,EhBV2C,CAAlD,EAAK,EAAL,EgBUoC,E,EAAS,C,CAAb,CAAvC,ElBzCO,E,wDkB+CW,E,KAAc,E,KhBhBG,E,EgBgBH,G,EhBhByB,CAAlD,EAAK,EAAL,EgBgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBjBG,E,EgBiBH,G,EhBjByB,CAAlD,EAAK,EAAL,E,EgBiBO,CAAd,E,EACA,E,KAAc,E,KhBlBqB,E,EgBkBrB,G,EhBlB2C,CAAlD,EAAK,EAAL,EgBkBgC,EAAS,EAAT,ChBvBhC,CgBuBP,ElBjDO,E,wDkBuDW,E,KAAc,E,KhBxBG,E,EgBwBH,G,EhBxByB,CAAlD,EAAK,EAAL,EgBwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBzBG,E,EgByBH,G,EhBzByB,CAAlD,EAAK,EAAL,E,EgByBO,CAAd,E,EACA,E,KAAc,E,KhB1BqB,E,EgB0BrB,G,EhB1B2C,CAAlD,EAAK,EAAL,EgB0BgC,EAAU,EAAV,ChB/BhC,CgB+BP,ElBzDO,E,sDkB+DW,E,KAAc,E,KhBhCG,E,EgBgCH,G,EhBhCyB,CAAlD,EAAK,EAAL,EgBgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KhBjCd,E,EgBiCc,G,EhBjCQ,CAAlD,EAAK,EAAL,E,EgBiCwB,CAA/B,E,EACA,E,KAAc,E,KhBlCqB,E,EgBkCrB,G,EhBlC2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ByBuB,CAAlD,EAAK,EAAL,EiBzBa,E,EAAuC,EjBoB5C,G,EAAA,G,CiBpBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YjBkBe,E,EiBlBD,G,EjBkBuB,CAAlD,EAAK,EAAL,EiBlBa,E,EAAuC,EjBa5C,G,EAAA,G,CiBbC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YjBWe,E,EiBXD,G,EjBWuB,CAAlD,EAAK,EAAL,EiBXa,E,EAAuC,EjBM5C,G,EAAA,G,CiBNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YjBIe,E,EiBJD,G,EjBIuB,CAAlD,EAAK,EAAL,EiBJa,E,EAAuC,EjBD5C,G,EAAA,G,CiBCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBFjB,GiBEG,G,OACD,E,KAAV,E,+DAKa,E,YjBHe,E,EiBGD,G,EjBHuB,CAAlD,EAAK,EAAL,EiBGa,E,EAAuC,EjBR5C,G,EAAA,G,CiBQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EjBJQ,E,EiBIoB,G,EjBJE,CAAlD,EAAK,EAAL,EiBIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YjBVe,E,EiBUD,G,EjBVuB,CAAlD,EAAK,EAAL,EiBUa,E,EAAuC,EjBf5C,G,EAAA,G,CiBeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EjBXO,E,EiBWsB,G,EjBXA,CAAlD,EAAK,EAAL,EiBWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBjBe,E,EiBiBD,G,EjBjBuB,CAAlD,EAAK,EAAL,EiBiBa,E,EAAuC,EjBtB5C,G,EAAA,G,CiBsBC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA3B,E,EjBlBO,E,EiBkBoB,G,EjBlBE,CAAlD,EAAK,EAAL,E,EiBkB8B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBxBe,E,EiBwBD,G,EjBxBuB,CAAl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ACb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,QAab,E,KAAa,E,KAAc,E,OpB9OI,E,EoB8OJ,G,EpB9O0B,CAAlD,EAAK,EAAL,EoB8OU,E,KACb,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAA2B,E,OpBrPhB,G,KoBsPX,E,KAA2B,E,OpBtPhB,G,QoByPX,E,KAAa,E,KAAc,E,OpBpPI,E,EoBoPJ,G,EpBpP0B,CAAlD,EAAK,EAAL,EoBoPU,E,KACb,E,KAAa,E,KAAc,E,OpBrPI,E,EoBqPJ,G,EpBrP0B,CAAlD,EAAK,EAAL,EoBqPU,E,KACb,E,KAAa,E,KAAc,E,OpBtPI,E,EoBsPJ,G,EpBtP0B,CAAlD,EAAK,EAAL,EoBsPU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBzMhB,G,QoB6MX,E,KAA2B,E,OpB7MhB,G,QoB2NX,E,KAAa,E,KAAc,E,OpBtNI,E,EoBsNJ,G,EpBtN0B,CAAlD,EAAK,EAAL,EoBsNU,E,KACb,E,KAA2B,E,OpB5NhB,G,QoByOX,E,KAAa,E,KAAc,E,OpBpOI,E,EoBoOJ,G,EpBpO0B,CAAlD,EAAK,EAAL,EoBoOU,E,KACb,E,KAAa,E,KAAc,E,OpBrOI,E,EoBqOJ,G,EpBrO0B,CAAlD,EAAK,EAAL,EoBqOU,E,MAbb,E,KAA2B,E,OpB7NhB,G,WoBuMJ,E,6CKnMoB,G,SACjB,E,wCnBkHkB,E,QAA9B,E,EACW,E,QAAX,E,6GbhII,EAAc,MAAd,CAAJ,EAA4E,I,iBAEvD,E,KAAJ,CAAgC,EAAhC,CAAjB,EACuD,EAA1C,E,OAIb,E,KAAc,E,oBACd,E,KAAiB,E,KACjB,E,KAAkB,E,KAClB,E,KAAe,E,iBayHC,EAAI,EAAJ,C,EACwB,EAAQ,EAAW,EAAX,CAAlC,CAAZ,E,GACyB,EAAnB,C,CAAN,E,EACY,E,KAAK,EAAY,E,GAA3B,E,KADF,GAF0B,E,GAAF,E,MAM1B,E,KAAc,EAAd,G,YmB3HsC,EAAxC,E,WACoB,GAAJ,G,IACE,E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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, Page, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getMemory(): Map {\n if (interpreter === null) {\n return new Map();\n }\n const int = interpreter;\n return int.memory.pages;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/release.wat b/build/release.wat index 6cd838e..8c9f3aa 100644 --- a/build/release.wat +++ b/build/release.wat @@ -2,8 +2,8 @@ (type $0 (func (param i32 i32 i32) (result i32))) (type $1 (func (param i32 i32) (result i32))) (type $2 (func (param i32) (result i32))) - (type $3 (func (param i32))) - (type $4 (func (result i32))) + (type $3 (func (result i32))) + (type $4 (func (param i32))) (type $5 (func (param i32 i32 i32))) (type $6 (func (param i32 i32))) (type $7 (func (param i32 i32 i32 i32) (result i32))) @@ -880,6 +880,7 @@ (export "getExitArg" (func $assembly/api-debugger/getExitArg)) (export "getGasLeft" (func $assembly/api-debugger/getGasLeft)) (export "setGasLeft" (func $assembly/api-debugger/setGasLeft)) + (export "getMemory" (func $assembly/api-debugger/getMemory)) (export "getRegisters" (func $assembly/api-debugger/getRegisters)) (export "getPageDump" (func $assembly/api-debugger/getPageDump)) (export "InputKind.Generic" (global $assembly/api-utils/InputKind.Generic)) @@ -5170,7 +5171,7 @@ select local.set $1 end - block $__inlined_func$~lib/rt/itcms/__renew$2434 + block $__inlined_func$~lib/rt/itcms/__renew$2437 local.get $4 i32.const 20 i32.sub @@ -5188,7 +5189,7 @@ i32.store offset=16 local.get $4 local.set $2 - br $__inlined_func$~lib/rt/itcms/__renew$2434 + br $__inlined_func$~lib/rt/itcms/__renew$2437 end local.get $1 local.get $3 @@ -10500,7 +10501,7 @@ i32.load offset=8 local.tee $8 i32.store - block $__inlined_func$assembly/memory/Memory#getPage$2439 (result i32) + block $__inlined_func$assembly/memory/Memory#getPage$2442 (result i32) local.get $8 local.get $6 call $"~lib/map/Map#has" @@ -10520,7 +10521,7 @@ local.get $7 local.get $5 call $assembly/memory/PageData#constructor - br $__inlined_func$assembly/memory/Memory#getPage$2439 + br $__inlined_func$assembly/memory/Memory#getPage$2442 end global.get $~lib/memory/__stack_pointer local.get $0 @@ -10566,7 +10567,7 @@ local.get $7 local.get $5 call $assembly/memory/PageData#constructor - br $__inlined_func$assembly/memory/Memory#getPage$2439 + br $__inlined_func$assembly/memory/Memory#getPage$2442 end global.get $~lib/memory/__stack_pointer global.get $assembly/memory/NO_PAGE_FAULT @@ -16815,7 +16816,7 @@ i64.const 13 i64.ge_u select - block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2444 (result i64) + block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2447 (result i64) global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 @@ -16916,7 +16917,7 @@ i64.const -1 i64.xor i64.add - br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2444 + br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2447 end local.get $3 i64.const 4294967295 @@ -27163,6 +27164,98 @@ call $~lib/builtins/abort unreachable ) + (func $"~lib/map/Map#constructor" (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.const 18 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 16 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + i32.const 48 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 4 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $0 + i32.const 0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + ) (func $assembly/memory-page/Arena#constructor (result i32) (local $0 i32) (local $1 i32) @@ -27433,157 +27526,76 @@ (func $assembly/memory/MemoryBuilder#constructor (result i32) (local $0 i32) (local $1 i32) - (local $2 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21764 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 45 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21764 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.const 18 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 16 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.store - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 48 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - call $assembly/memory-page/Arena#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable end - i32.const 54560 - i32.const 54608 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 45 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + call $"~lib/map/Map#constructor" + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + call $assembly/memory-page/Arena#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 ) (func $assembly/memory/MemoryBuilder#getOrCreatePageForAddress (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i32) @@ -29482,7 +29494,7 @@ i32.const 19584 call $~lib/staticarray/StaticArray<~lib/string/String>#join i32.const 19360 - i32.const 192 + i32.const 200 i32.const 5 call $~lib/builtins/abort unreachable @@ -31739,6 +31751,72 @@ i32.add global.set $~lib/memory/__stack_pointer ) + (func $assembly/api-debugger/getMemory (result i32) + (local $0 i32) + (local $1 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.eqz + if + call $"~lib/map/Map#constructor" + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 141 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $0 + i32.store offset=8 + local.get $0 + i32.load offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) (func $assembly/api-debugger/getRegisters (result i32) (local $0 i32) (local $1 i32) @@ -31797,7 +31875,7 @@ if i32.const 10512 i32.const 19360 - i32.const 143 + i32.const 151 i32.const 28 call $~lib/builtins/abort unreachable @@ -31910,7 +31988,7 @@ if i32.const 10512 i32.const 19360 - i32.const 168 + i32.const 176 i32.const 28 call $~lib/builtins/abort unreachable @@ -31948,7 +32026,7 @@ i32.load offset=8 local.tee $1 i32.store - block $__inlined_func$assembly/memory/Memory#pageDump$2492 + block $__inlined_func$assembly/memory/Memory#pageDump$2494 local.get $1 local.get $0 call $"~lib/map/Map#has" @@ -31960,7 +32038,7 @@ global.set $~lib/memory/__stack_pointer i32.const 0 local.set $0 - br $__inlined_func$assembly/memory/Memory#pageDump$2492 + br $__inlined_func$assembly/memory/Memory#pageDump$2494 end global.get $~lib/memory/__stack_pointer local.get $3 @@ -32943,7 +33021,7 @@ global.get $~lib/memory/__stack_pointer i32.const 16080 i32.store - block $__inlined_func$~lib/string/String#padStart$2530 + block $__inlined_func$~lib/string/String#padStart$2532 i32.const 16076 i32.load i32.const -2 @@ -32959,7 +33037,7 @@ i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#padStart$2530 + br $__inlined_func$~lib/string/String#padStart$2532 end global.get $~lib/memory/__stack_pointer i32.const 4 @@ -33463,7 +33541,7 @@ i32.const 1 i32.shl local.set $3 - block $__inlined_func$~lib/string/String#substring$2531 + block $__inlined_func$~lib/string/String#substring$2533 local.get $2 i32.const 0 local.get $2 @@ -33484,7 +33562,7 @@ global.set $~lib/memory/__stack_pointer i32.const 15504 local.set $0 - br $__inlined_func$~lib/string/String#substring$2531 + br $__inlined_func$~lib/string/String#substring$2533 end local.get $3 i32.eqz @@ -33499,7 +33577,7 @@ i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#substring$2531 + br $__inlined_func$~lib/string/String#substring$2533 end global.get $~lib/memory/__stack_pointer local.get $4 @@ -36472,7 +36550,7 @@ end else global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2322 (result i32) + block $__inlined_func$~lib/util/number/ulog_base$2325 (result i32) local.get $0 i64.extend_i32_u local.set $4 @@ -36493,7 +36571,7 @@ i32.div_u i32.const 1 i32.add - br $__inlined_func$~lib/util/number/ulog_base$2322 + br $__inlined_func$~lib/util/number/ulog_base$2325 end local.get $1 i64.extend_i32_s @@ -36811,7 +36889,7 @@ end else global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2327 (result i32) + block $__inlined_func$~lib/util/number/ulog_base$2330 (result i32) local.get $0 local.set $2 local.get $1 @@ -36831,7 +36909,7 @@ i32.div_u i32.const 1 i32.add - br $__inlined_func$~lib/util/number/ulog_base$2327 + br $__inlined_func$~lib/util/number/ulog_base$2330 end local.get $1 i64.extend_i32_s @@ -37921,7 +37999,7 @@ if i32.const 10512 i32.const 19360 - i32.const 160 + i32.const 168 i32.const 28 call $~lib/builtins/abort unreachable @@ -38003,7 +38081,7 @@ if i32.const 10512 i32.const 19360 - i32.const 181 + i32.const 189 i32.const 28 call $~lib/builtins/abort unreachable From c5180693614abda137f6fc816e18b9436ec48cbe Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Tue, 14 Oct 2025 10:58:03 +0200 Subject: [PATCH 06/21] added set/get register, get memory --- assembly/api-debugger.ts | 29 +- build/debug.d.ts | 25 +- build/debug.js | 19 +- build/debug.wasm | Bin 198058 -> 199136 bytes build/debug.wasm.map | 2 +- build/debug.wat | 408 ++++++++- build/release.d.ts | 25 +- build/release.js | 19 +- build/release.wasm | Bin 97107 -> 97772 bytes build/release.wasm.map | 2 +- build/release.wat | 1681 ++++++++++++++++++++++---------------- 11 files changed, 1468 insertions(+), 742 deletions(-) diff --git a/assembly/api-debugger.ts b/assembly/api-debugger.ts index e39ef54..788245a 100644 --- a/assembly/api-debugger.ts +++ b/assembly/api-debugger.ts @@ -3,7 +3,7 @@ import { Decoder } from "./codec"; import { Gas } from "./gas"; import { Interpreter, Status } from "./interpreter"; import { MemoryBuilder } from "./memory"; -import { Access, Page, PAGE_SIZE } from "./memory-page"; +import { Access, PAGE_SIZE } from "./memory-page"; import { deblob, extractCodeAndMetadata, liftBytes } from "./program"; import { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from "./registers"; import { decodeSpi } from "./spi"; @@ -134,12 +134,20 @@ export function setGasLeft(gas: i64): void { } } -export function getMemory(): Map { +export function getRegister(reg: u8): u64 { if (interpreter === null) { - return new Map(); + return 0; + } + const int = interpreter; + return int.registers[reg]; +} + +export function setRegister(reg: u8, value: u64): void { + if (interpreter === null) { + return; } const int = interpreter; - return int.memory.pages; + int.registers[reg] = value; } export function getRegisters(): Uint8Array { @@ -182,6 +190,19 @@ export function getPageDump(index: u32): Uint8Array { return page; } +export function getMemory(address: u32, length: u32): Uint8Array { + if (interpreter === null) { + return new Uint8Array(0); + } + const int = interpreter; + const result = new Uint8Array(length); + const fault = int.memory.bytesRead(address, result); + if (fault.isFault) { + return new Uint8Array(0); + } + return result; +} + export function setMemory(address: u32, data: Uint8Array): void { if (interpreter === null) { return; diff --git a/build/debug.d.ts b/build/debug.d.ts index e25b027..30d217a 100644 --- a/build/debug.d.ts +++ b/build/debug.d.ts @@ -81,10 +81,17 @@ export declare function getGasLeft(): bigint; */ export declare function setGasLeft(gas: bigint): void; /** - * assembly/api-debugger/getMemory - * @returns `~lib/map/Map` + * assembly/api-debugger/getRegister + * @param reg `u8` + * @returns `u64` + */ +export declare function getRegister(reg: number): bigint; +/** + * assembly/api-debugger/setRegister + * @param reg `u8` + * @param value `u64` */ -export declare function getMemory(): __Internref18; +export declare function setRegister(reg: number, value: bigint): void; /** * assembly/api-debugger/getRegisters * @returns `~lib/typedarray/Uint8Array` @@ -101,6 +108,13 @@ export declare function setRegisters(flatRegisters: Array): void; * @returns `~lib/typedarray/Uint8Array` */ export declare function getPageDump(index: number): Uint8Array; +/** + * assembly/api-debugger/getMemory + * @param address `u32` + * @param length `u32` + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function getMemory(address: number, length: number): Uint8Array; /** * assembly/api-debugger/setMemory * @param address `u32` @@ -164,11 +178,6 @@ declare class __Internref30 extends Number { private __nominal30: symbol; private __nominal0: symbol; } -/** ~lib/map/Map */ -declare class __Internref18 extends Number { - private __nominal18: symbol; - private __nominal0: symbol; -} /** assembly/gas-costs/BlockGasCost */ declare interface __Record54 { /** @type `u32` */ diff --git a/build/debug.js b/build/debug.js index 8028789..1e7cdd6 100644 --- a/build/debug.js +++ b/build/debug.js @@ -96,9 +96,14 @@ async function instantiate(module, imports = {}) { gas = gas || 0n; exports.setGasLeft(gas); }, - getMemory() { - // assembly/api-debugger/getMemory() => ~lib/map/Map - return __liftInternref(exports.getMemory() >>> 0); + getRegister(reg) { + // assembly/api-debugger/getRegister(u8) => u64 + return BigInt.asUintN(64, exports.getRegister(reg)); + }, + setRegister(reg, value) { + // assembly/api-debugger/setRegister(u8, u64) => void + value = value || 0n; + exports.setRegister(reg, value); }, getRegisters() { // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array @@ -113,6 +118,10 @@ async function instantiate(module, imports = {}) { // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); }, + getMemory(address, length) { + // assembly/api-debugger/getMemory(u32, u32) => ~lib/typedarray/Uint8Array + return __liftTypedArray(Uint8Array, exports.getMemory(address, length) >>> 0); + }, setMemory(address, data) { // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); @@ -389,10 +398,12 @@ export const { getExitArg, getGasLeft, setGasLeft, - getMemory, + getRegister, + setRegister, getRegisters, setRegisters, getPageDump, + getMemory, setMemory, InputKind, HasMetadata, diff --git a/build/debug.wasm b/build/debug.wasm index 22eeef61b1d68ebcaf0e61d9f48f56cf766717d3..8e26c3e21b12a3a3aa88ce4e210376a001db7493 100644 GIT binary patch delta 4843 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 delta 4081 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 I;-!TD0T*Qq-v9sr diff --git a/build/debug.wasm.map b/build/debug.wasm.map index f8204e6..ad5e214 100644 --- a/build/debug.wasm.map +++ b/build/debug.wasm.map @@ -1 +1 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, Page, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getMemory(): Map {\n if (interpreter === null) {\n return new Map();\n }\n const int = interpreter;\n return int.memory.pages;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/debug.wat b/build/debug.wat index 51b0126..3738938 100644 --- a/build/debug.wat +++ b/build/debug.wat @@ -6,8 +6,8 @@ (type $4 (func (param i32 i32 i32))) (type $5 (func (param i32 i32 i32 i32) (result i32))) (type $6 (func (param i32))) - (type $7 (func)) - (type $8 (func (param i32) (result i64))) + (type $7 (func (param i32) (result i64))) + (type $8 (func)) (type $9 (func (param i32 i64))) (type $10 (func (result i32))) (type $11 (func (param i64 i64) (result i64))) @@ -695,9 +695,11 @@ (export "getExitArg" (func $assembly/api-debugger/getExitArg)) (export "getGasLeft" (func $assembly/api-debugger/getGasLeft)) (export "setGasLeft" (func $assembly/api-debugger/setGasLeft)) - (export "getMemory" (func $assembly/api-debugger/getMemory)) + (export "getRegister" (func $assembly/api-debugger/getRegister)) + (export "setRegister" (func $assembly/api-debugger/setRegister)) (export "getRegisters" (func $assembly/api-debugger/getRegisters)) (export "getPageDump" (func $assembly/api-debugger/getPageDump)) + (export "getMemory" (func $assembly/api-debugger/getMemory)) (export "InputKind.Generic" (global $assembly/api-utils/InputKind.Generic)) (export "InputKind.SPI" (global $assembly/api-utils/InputKind.SPI)) (export "HasMetadata.Yes" (global $assembly/api-utils/HasMetadata.Yes)) @@ -35264,7 +35266,7 @@ local.get $9 call $~lib/staticarray/StaticArray<~lib/string/String>#join i32.const 18336 - i32.const 200 + i32.const 221 i32.const 5 call $~lib/builtins/abort unreachable @@ -38804,10 +38806,11 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/api-debugger/getMemory (result i32) - (local $0 i32) + (func $assembly/api-debugger/getRegister (param $reg i32) (result i64) + (local $1 i32) (local $int i32) - (local $2 i32) + (local $3 i32) + (local $4 i64) global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub @@ -38823,24 +38826,23 @@ i32.const 0 i32.eq if - i32.const 0 - call $"~lib/map/Map#constructor" - local.set $2 + i64.const 0 + local.set $4 global.get $~lib/memory/__stack_pointer i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $4 return end global.get $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer global.get $assembly/api-debugger/interpreter - local.tee $0 + local.tee $1 i32.store - local.get $0 + local.get $1 if (result i32) - local.get $0 + local.get $1 else i32.const 9488 i32.const 18336 @@ -38852,26 +38854,94 @@ local.tee $int i32.store offset=4 local.get $int - local.set $2 + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $3 i32.store offset=12 - local.get $2 - call $assembly/interpreter/Interpreter#get:memory - local.set $2 + local.get $3 + call $assembly/interpreter/Interpreter#get:registers + local.set $3 global.get $~lib/memory/__stack_pointer - local.get $2 + local.get $3 i32.store offset=8 - local.get $2 - call $assembly/memory/Memory#get:pages - local.set $2 + local.get $3 + local.get $reg + i32.const 255 + i32.and + call $~lib/staticarray/StaticArray#__get + local.set $4 global.get $~lib/memory/__stack_pointer i32.const 16 i32.add global.set $~lib/memory/__stack_pointer - local.get $2 + local.get $4 return ) + (func $assembly/api-debugger/setRegister (param $reg i32) (param $value i64) + (local $2 i32) + (local $int i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.eq + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $2 + i32.store + local.get $2 + if (result i32) + local.get $2 + else + i32.const 9488 + i32.const 18336 + i32.const 149 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + local.get $int + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=12 + local.get $4 + call $assembly/interpreter/Interpreter#get:registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + local.get $reg + i32.const 255 + i32.and + local.get $value + call $~lib/staticarray/StaticArray#__set + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) (func $assembly/api-debugger/getRegisters (result i32) (local $flat i32) (local $1 i32) @@ -38933,7 +39003,7 @@ else i32.const 9488 i32.const 18336 - i32.const 151 + i32.const 159 i32.const 28 call $~lib/builtins/abort unreachable @@ -39062,7 +39132,7 @@ else i32.const 9488 i32.const 18336 - i32.const 168 + i32.const 176 i32.const 28 call $~lib/builtins/abort unreachable @@ -39216,7 +39286,7 @@ else i32.const 9488 i32.const 18336 - i32.const 176 + i32.const 184 i32.const 28 call $~lib/builtins/abort unreachable @@ -39275,6 +39345,288 @@ local.get $4 return ) + (func $assembly/memory/Memory#bytesRead (param $this i32) (param $address i32) (param $destination i32) (result i32) + (local $nextAddress i32) + (local $destinationIndex i32) + (local $bytesLeft i32) + (local $pageData i32) + (local $relAddress i32) + (local $bytesToRead i32) + (local $source i32) + (local $10 i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + local.get $address + local.set $nextAddress + i32.const 0 + local.set $destinationIndex + loop $while-continue|0 + local.get $destinationIndex + local.get $destination + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + i32.lt_s + if + local.get $destination + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $~lib/typedarray/Uint8Array#get:length + local.get $destinationIndex + i32.sub + local.set $bytesLeft + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + global.get $assembly/memory-page/Access.Read + local.get $nextAddress + call $assembly/memory/Memory#getPage + local.tee $pageData + i32.store offset=4 + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory/PageData#get:fault + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:fault + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + end + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:relativeAddress + local.set $relAddress + local.get $relAddress + local.get $bytesLeft + i32.add + global.get $assembly/memory-page/PAGE_SIZE + i32.lt_u + if (result i32) + local.get $bytesLeft + else + global.get $assembly/memory-page/PAGE_SIZE + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + call $assembly/memory/PageData#get:relativeAddress + i32.sub + end + local.set $bytesToRead + global.get $~lib/memory/__stack_pointer + local.get $pageData + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=16 + local.get $10 + call $assembly/memory/PageData#get:page + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=12 + local.get $10 + call $assembly/memory-page/Page#get:raw + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + call $assembly/memory-page/RawPage#get:data + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $relAddress + local.get $relAddress + local.get $bytesToRead + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $source + i32.store offset=20 + local.get $destination + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store + local.get $10 + local.get $source + local.set $10 + global.get $~lib/memory/__stack_pointer + local.get $10 + i32.store offset=8 + local.get $10 + local.get $destinationIndex + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $destinationIndex + local.get $bytesToRead + i32.add + local.set $destinationIndex + local.get $nextAddress + local.get $bytesToRead + i32.add + local.set $nextAddress + br $while-continue|0 + end + end + global.get $assembly/memory/NO_PAGE_FAULT + local.set $10 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $10 + return + ) + (func $assembly/api-debugger/getMemory (param $address i32) (param $length i32) (result i32) + (local $2 i32) + (local $int i32) + (local $result i32) + (local $fault i32) + (local $6 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + global.get $assembly/api-debugger/interpreter + i32.const 0 + i32.eq + if + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $2 + i32.store + local.get $2 + if (result i32) + local.get $2 + else + i32.const 9488 + i32.const 18336 + i32.const 197 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.tee $int + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 0 + local.get $length + call $~lib/typedarray/Uint8Array#constructor + local.tee $result + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $int + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + local.get $6 + call $assembly/interpreter/Interpreter#get:memory + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + local.get $address + local.get $result + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=16 + local.get $6 + call $assembly/memory/Memory#bytesRead + local.tee $fault + i32.store offset=24 + local.get $fault + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=12 + local.get $6 + call $assembly/memory/MaybePageFault#get:isFault + if + i32.const 0 + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + end + local.get $result + local.set $6 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $6 + return + ) (func $assembly/api-debugger/setMemory (param $address i32) (param $data i32) (local $2 i32) (local $int i32) @@ -39313,7 +39665,7 @@ else i32.const 9488 i32.const 18336 - i32.const 189 + i32.const 210 i32.const 28 call $~lib/builtins/abort unreachable diff --git a/build/release.d.ts b/build/release.d.ts index e25b027..30d217a 100644 --- a/build/release.d.ts +++ b/build/release.d.ts @@ -81,10 +81,17 @@ export declare function getGasLeft(): bigint; */ export declare function setGasLeft(gas: bigint): void; /** - * assembly/api-debugger/getMemory - * @returns `~lib/map/Map` + * assembly/api-debugger/getRegister + * @param reg `u8` + * @returns `u64` + */ +export declare function getRegister(reg: number): bigint; +/** + * assembly/api-debugger/setRegister + * @param reg `u8` + * @param value `u64` */ -export declare function getMemory(): __Internref18; +export declare function setRegister(reg: number, value: bigint): void; /** * assembly/api-debugger/getRegisters * @returns `~lib/typedarray/Uint8Array` @@ -101,6 +108,13 @@ export declare function setRegisters(flatRegisters: Array): void; * @returns `~lib/typedarray/Uint8Array` */ export declare function getPageDump(index: number): Uint8Array; +/** + * assembly/api-debugger/getMemory + * @param address `u32` + * @param length `u32` + * @returns `~lib/typedarray/Uint8Array` + */ +export declare function getMemory(address: number, length: number): Uint8Array; /** * assembly/api-debugger/setMemory * @param address `u32` @@ -164,11 +178,6 @@ declare class __Internref30 extends Number { private __nominal30: symbol; private __nominal0: symbol; } -/** ~lib/map/Map */ -declare class __Internref18 extends Number { - private __nominal18: symbol; - private __nominal0: symbol; -} /** assembly/gas-costs/BlockGasCost */ declare interface __Record54 { /** @type `u32` */ diff --git a/build/release.js b/build/release.js index 2887c57..2061561 100644 --- a/build/release.js +++ b/build/release.js @@ -96,9 +96,14 @@ async function instantiate(module, imports = {}) { gas = gas || 0n; exports.setGasLeft(gas); }, - getMemory() { - // assembly/api-debugger/getMemory() => ~lib/map/Map - return __liftInternref(exports.getMemory() >>> 0); + getRegister(reg) { + // assembly/api-debugger/getRegister(u8) => u64 + return BigInt.asUintN(64, exports.getRegister(reg)); + }, + setRegister(reg, value) { + // assembly/api-debugger/setRegister(u8, u64) => void + value = value || 0n; + exports.setRegister(reg, value); }, getRegisters() { // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array @@ -113,6 +118,10 @@ async function instantiate(module, imports = {}) { // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); }, + getMemory(address, length) { + // assembly/api-debugger/getMemory(u32, u32) => ~lib/typedarray/Uint8Array + return __liftTypedArray(Uint8Array, exports.getMemory(address, length) >>> 0); + }, setMemory(address, data) { // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); @@ -389,10 +398,12 @@ export const { getExitArg, getGasLeft, setGasLeft, - getMemory, + getRegister, + setRegister, getRegisters, setRegisters, getPageDump, + getMemory, setMemory, InputKind, HasMetadata, diff --git a/build/release.wasm b/build/release.wasm index a15a2cc5756ee93e1146b9fc5adbb72d0f7315cc..4e337401b5c86b24e5ad8b75dfaf22f3757c8930 100644 GIT binary patch delta 7137 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 delta 6553 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 diff --git a/build/release.wasm.map b/build/release.wasm.map index 2debc2e..7d03317 100644 --- a/build/release.wasm.map +++ b/build/release.wasm.map @@ -1 +1 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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V,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDzCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAG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AAc,E,KAAA,G,IAAW,E,KLkBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTuIO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDS/IM,E,KAAc,E,YAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/EgB,CAAlD,EAAK,EAAL,EU+EoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVjFN,E,EUiFM,G,EVjFgB,CAAlD,EAAK,EAAL,EUiFoB,E,IAAyB,E,KAAc,E,KVjF/B,E,EAAsB,CAAlD,EAAK,EAAL,EUiFoB,E,EVjFQ,E,EUiF+B,G,EVjFT,CAAlD,EAAK,EAAL,EUiF6C,EAAzB,CAAzB,GZhHK,E,sDYuHO,E,KAAc,E,KVxFO,E,EUwFP,G,EVxF6B,CAAlD,EAAK,EAAL,EUwFG,EAAV,E,EACc,E,KAAc,E,KVzFO,E,EUyFP,G,EVzF6B,CAAlD,EAAK,EAAL,EUyFG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KV3FmB,E,EU2FnB,G,EV3FyC,CAAlD,EAAK,EAAL,EU2FoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV7FmB,E,EU6FnB,G,EV7FyC,CAAlD,EAAK,EAAL,EU6FoB,EAAzB,G,EAEA,E,KAAc,E,KV/FmB,E,EU+FnB,G,EV/FyC,CAAlD,EAAK,EAAL,EU+FoB,EAAI,EAAJ,CAAzB,IZ9HK,E,6DYqIP,E,KAAc,E,KAAA,G,IAA8B,E,KAAc,E,KVtGvB,E,EUsGuB,G,EVtGD,CAAlD,EAAK,EAAL,EUsGiC,E,IAAiC,E,KAAc,E,KVtGpD,E,EAAsB,CAAlD,EAAK,EAAL,E,IAA4B,E,EUsGoD,G,EVtG9B,CAAlD,EAAK,EAAL,EUsG8D,EVpJrE,EADA,EAEQ,EAAJ,CAAJ,EAEU,E,EAAD,CAAK,EAAL,CAAP,EADmB,G,GAAnB,EAGE,EAAI,EAAJ,CAAJ,EAEU,E,EAAD,CAAK,EAAL,CAAP,EADoB,EAAD,E,GAIrB,EACuC,EA7Bf,EAAL,CAAnB,EADkB,EAAI,MAAJ,CAAlB,EAKgB,CAAhB,EAyBiC,EA/BT,EAAL,CAAnB,EAGkB,EAAI,MAAJ,CAAlB,EAIgB,CAAhB,EAyBuB,EAAP,GACG,EAjCnB,EAEA,EAMiB,CAFjB,EAK8B,EAAX,CAAZ,CAJP,EAIgD,EAAX,CAA9B,CAFyB,EAAU,MAAV,CAJjB,EAAO,EAAP,CAIU,EAAV,CAAD,CAA4C,EAAU,MAAV,CAA5C,CAEkD,EAAT,CAAhD,C,EAsBE,EAAP,GAG4B,EAlCN,EAAL,CAAnB,EADkB,EAAI,MAAJ,CAAlB,EAKgB,CAAhB,EA8BwB,EApCA,EAAL,CAAnB,EAEA,EAMiB,CAFjB,EAK8B,EAAX,CAAZ,CARW,EAAI,MAAJ,CAAlB,EAIgB,GAAhB,EAIgD,EAAX,CAA9B,CAFyB,EAAU,MAAV,CAJV,EAAP,GAIU,EAAV,CAAD,CAA4C,EAAU,MAAV,CAA5C,CAEkD,EAAT,CAAhD,EU6JP,EZrIO,E,6DY2IP,E,KAAc,E,KAAA,G,IAA4B,E,KAAc,E,KV5GrB,E,EU4GqB,G,EV5GC,CAAlD,EAAK,EAAL,EU4GmC,E,IAAwB,E,KAAc,E,KV5G7C,E,EU4G6C,G,EV5GvB,CAAlD,EAAK,EAAL,EU4G2D,EV5K/C,EAAK,EAAL,CAAnB,EAFmB,EAAK,EAAL,CAAnB,EAGkB,EAAI,MAAJ,CAAlB,EAIgB,CAAhB,E,EA2DmC,E,EAAsB,CAAlD,EAAK,EAAL,EA1DkB,EAAR,GAPC,EAAI,MAAJ,CAAlB,EAKuB,EAAP,CAAhB,EAK8B,EAAX,CAAZ,CAA8B,EAAW,EAAX,CAA9B,CAFyB,EAAU,MAAV,CAJjB,EAAO,EAAP,CAIU,EAAV,CAAD,CAA4C,EAAU,MAAV,CAA5C,CAEkD,EAAT,CAAhD,CUmKP,EZ3IO,E,6DYiJP,E,KAAc,E,KVlHqB,E,EUkHrB,G,EVlH2C,CAAlD,EAAK,EAAL,E,IUkH6C,E,KAAc,E,KVlH/B,E,EUkH+B,G,EVlHT,CAAlD,EAAK,EAAL,EUkHyC,E,IAA6B,E,KAAc,E,KVlHxD,E,EUkHwD,G,EVlHlC,CAAlD,EAAK,EAAL,EUkHsE,E,EV5IzE,EAAI,EAAJ,CAAJ,EACqB,E,EAAD,CAAK,EAAL,CAAlB,EAxCoB,MAAJ,CAAlB,EAyCuC,EAxCf,EAAL,CAAnB,EAIgB,CAAhB,EAoCiC,EA1CT,EAAL,CAAnB,EAGkB,EAAI,MAAJ,CAAlB,EAIgB,CAAhB,EAoCuB,EAFrB,EAEc,CACG,EA5CnB,EAQyB,EAAR,CAFjB,EAK8B,EAAX,CAAZ,CAJP,EAIgD,EAAX,CAA9B,CAFyB,EAAU,MAAV,CAJjB,EAAO,EAAP,CAIU,EAAV,CAAD,CAA4C,EAAU,MAAV,CAA5C,CAEkD,EAAT,CAAhD,C,EAiCE,EAAP,GA3CgB,EAAI,MAAJ,CAAlB,EA6C2B,EA5CH,EAAL,CAAnB,EAIgB,CAAhB,EAwCwB,EA9CA,EAAL,CAAnB,EAGkB,EAAI,MAAJ,CAAlB,EAIgB,CAAhB,EAPA,EAQyB,EAAR,CAFjB,EAK8B,EAAX,CAAZ,CAJP,EAIgD,EAAX,CAA9B,CAFyB,EAAU,MAAV,CAJjB,EAAO,EAAP,CAIU,EAAV,CAAD,CAA4C,EAAU,MAAV,CAA5C,CAEkD,EAAT,CAAhD,EUyKP,EZjJO,E,sDYuJO,E,KAAc,E,KVxHO,E,EUwHP,G,EVxH6B,CAAlD,EAAK,EAAL,EUwHG,EAAV,E,EACc,E,KAAc,E,KVzHO,E,EUyHP,G,EVzH6B,CAAlD,EAAK,EAAL,EUyHG,EAAV,E,EACA,E,KAAc,E,KV1HqB,E,EU0HrB,G,EV1H2C,CAAlD,EAAK,EAAL,EU0H0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZzJO,E,sDY+JG,E,KAAc,E,KVhIW,E,EUgIX,G,EVhIiC,CAAlD,EAAK,EAAL,EUgIG,EAAV,E,EACU,E,KAAc,E,KVjIW,E,EUiIX,G,EVjIiC,CAAlD,EAAK,EAAL,EUiIG,EAAV,E,EACA,E,KAAc,E,KVlIqB,E,EUkIrB,G,EVlI2C,CAAlD,EAAK,EAAL,EUkI0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZjKO,E,sDYuKO,E,KAAc,E,KVxIO,E,EUwIP,G,EVxI6B,CAAlD,EAAK,EAAL,EUwIG,EAAV,E,EACc,E,KAAc,E,KVzIO,E,EUyIP,G,EVzI6B,CAAlD,EAAK,EAAL,EUyIG,EAAV,E,EACA,E,KAAc,E,KV1IqB,E,EU0IrB,G,EV1I2C,CAAlD,EAAK,EAAL,EU0I0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZzKO,E,sDY+KG,E,KAAc,E,KVhJW,E,EUgJX,G,EVhJiC,CAAlD,EAAK,EAAL,EUgJG,EAAV,E,EACU,E,KAAc,E,KVjJW,E,EUiJX,G,EVjJiC,CAAlD,EAAK,EAAL,EUiJG,EAAV,E,EACA,E,KAAc,E,KVlJqB,E,EUkJrB,G,EVlJ2C,CAAlD,EAAK,EAAL,EUkJ0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZjLO,E,sCatCgD,E,mCb8C7C,E,OACV,E,KAAY,E,KACZ,E,KAAW,E,KACX,E,KAAa,E,gFLqBJ,E,2DmBxEK,E,KAAZ,E,+CjBsDI,E,iBAAA,GAAmB,EAAnB,CAAJ,E,EACS,E,wCF2MC,E,QAAV,EACU,EAAN,CAAJ,EAAkC,I,eAChB,E,UAA4B,E,GAAV,EAAkB,EAAlB,CAAlB,CAAR,G,OACV,E,KAAe,E,iBACR,EE/ML,E,EAGsB,E,QAAsB,EAAtB,CAAxB,E,EAEwB,E,GAApB,E,KAAA,CAAJ,E,aACE,I,EAIW,EAAkB,MAAlB,GAAoD,GAAf,GAA4B,G,OAC9E,E,KAAA,E,UAAuB,E,MACJ,E,UAAqB,E,KAAjC,E,gEWiCK,E,KAAU,EADC,EC1Ed,MAAN,CADQ,M,CAEA,EAAR,CAAc,MAAd,CAAL,IACU,EAAL,C,CACA,M,CAAL,IACU,EAAL,C,CACA,M,CAAL,IACU,EAAL,C,CDoEH,EACY,EAAZ,EACA,E,EACgB,E,GAAd,E,KAES,EAAyB,EAA0B,EADxC,G,EAKhB,E,UAAsB,E,QAAtB,CAAJ,E,EACE,E,KACE,E,UAAoB,K,KAAuB,EAAvB,CAAuC,EAAvC,CAApB,G,EACK,E,WACA,K,KAAoB,EAApB,CAAyB,EAA1B,E,kCAuCqB,EAAiB,EAAvB,CAAzB,EACsD,EAArB,CAAhB,G,OACQ,EAAqB,EAArB,CAAqC,EAArC,CAAzB,EACsD,EAArB,CAAhB,G,OAGc,E,QAA/B,E,EAC6B,E,GAAhB,E,KAAqC,EAA5B,CAAT,CAAb,EACa,EAAb,EACA,EAAiB,EAAV,G,EACU,E,GACa,EAAtB,C,CAAN,EACiB,EACG,E,GAAlB,E,KAEiB,E,QAAjB,E,KAGA,EADuB,EADqB,EAAf,EC9IxB,MAAN,CADQ,M,CAEA,EAAR,CAAc,MAAd,CAAL,EACU,EAAL,CADL,E,CAEK,M,CAAL,EACU,EAAL,CADL,E,CAEK,M,CAAL,EACU,EAAL,CADL,E,CDyI2B,CAC0D,EAAxB,CAAhC,CAAvB,EACsB,G,GACT,EAAkB,EAA/B,GACA,EAAU,E,CAAV,GAEF,EAAU,E,CAAV,E,MAGF,E,KAAe,E,oBACf,E,KAAmB,E,KACnB,E,KAAe,E,oBACf,E,KAAuB,E,KACvB,E,KAAqB,E,uBAhEL,E,iBACyD,E,KAAA,E,kBAArC,E,EAA6D,EAAhC,CAAvD,CAAR,EAEY,E,KAIE,E,GAAd,E,KAES,EAAyB,EAA0B,EADxC,E,EAGlB,E,KAAA,E,kBAEoC,E,YAAmC,EAAnB,GACtD,E,EAD8D,E,KAAR,CAAuC,EAAvC,CAAlC,CAApB,EACmB,G,GACN,EAAe,EAA5B,I,kEK7HQ,E,KAAgB,E,KAAc,E,OXiEP,E,EWjEO,G,EXiEe,CAAlD,EAAK,EAAL,E,EWjEiB,C,6Bf0HE,E,OACxB,E,sBACI,GAAJ,E,EAIoB,E,KAAJ,GAAwB,E,CAAxB,CAAhB,EACe,MAAX,CAAJ,E,EACE,E,iBAAgC,E,QAGlC,E,YAGgB,E,GADK,EAAU,EAAV,CAAgB,E,CAArB,CAAhB,E,KACI,CAAJ,E,EAIa,E,QAAyB,EAAzB,CAAR,E,EAAoC,EAAK,EAAL,C,IAC1B,E,mBAAA,G,OACb,E,iBAAyC,E,GAAd,E,EAAT,E,WAAH,E,KAFsC,E,GAAA,E,MAKvD,E,KAAyB,E,WAClB,E,OehJL,E,oBAAJ,E,EACmB,E,iBAAV,E,OAAP,E,EAEF,E,KAAc,E,KAAA,G,IAAW,E,KX4DU,E,EAAsB,CAAlD,EAAK,EAAL,E,KW5DP,Eb6BO,E,8Ee9CP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb6EJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea7EI,G,Eb6EkB,CAAlD,EAAK,EAAL,Ea7EkB,EAAzB,Ef8CO,E,sDexCH,E,KAAc,E,KbuEiB,E,EavEjB,G,EbuEuC,CAAlD,EAAK,EAAL,EavEH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EbiE1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GajEb,GfuCK,E,sDehCH,E,KAAc,E,Kb+DiB,E,Ea/DjB,G,Eb+DuC,CAAlD,EAAK,EAAL,Ea/DH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EbyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GazDb,Gf+BK,E,6DexBH,E,KAAc,E,KbuDiB,E,EavDjB,G,EbuDuC,CAAlD,EAAK,EAAL,EavDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EatDM,G,EbsDgB,CAAlD,EAAK,EAAL,EatDoB,EAAzB,GfuBK,E,6DehBH,E,KAAc,E,Kb+CiB,E,Ea/CjB,G,Eb+CuC,CAAlD,EAAK,EAAL,Ea/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea9CM,G,Eb8CgB,CAAlD,EAAK,EAAL,Ea9CoB,EAAzB,GfeK,E,6DgB9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,Kd6EL,E,Ec7EK,G,Ed6EiB,CAAlD,EAAK,EAAL,Ec7EwB,E,IAAiC,EdwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,Ec7EwB,E,EdwEhB,GcvBN,CAjDT,EhB8CO,E,6DgBxCP,E,YAAS,G,IAAoC,E,KdkE9B,G,IclEuC,E,KAAS,E,KduE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EcvE4B,G,EduEN,CAAlD,EAAK,EAAL,EcvE+C,EA2C7C,CA3CT,EhBwCO,E,6DgBlCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdiE1B,E,EcjE0B,G,EdiEJ,CAAlD,EAAK,EAAL,E,EcjEyC,C,IAA4B,EAyCtD,G,EdwBa,E,EAAsB,CAAlD,EAAK,EAAL,EcjEyC,E,EAyC1B,GAAb,CdmBF,Cc5DP,EhBkCO,E,6DgB5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,Kd2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EcxBY,E,EdwBgB,E,Ec3DuC,G,Ed2DjB,CAAlD,EAAK,EAAL,E,Ec3DsD,CAmCpD,CdmBF,CctDP,EhB4BO,E,6DgBtBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdqDL,E,EcrDK,G,EdqDiB,CAAlD,EAAK,EAAL,EcrDwB,E,IAAmB,E,KAAS,E,KdqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EcrDwB,E,EdqDI,E,EcrDwB,G,EdqDF,CAAlD,EAAK,EAAL,EcrD2C,EAiCzC,CAjCT,EhBsBO,E,6DgBhBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,Kd+C1B,E,Ec/C0B,G,Ed+CJ,CAAlD,EAAK,EAAL,E,Ec/CyC,C,IAA4B,E,KAAS,E,Kd+ClD,E,EAAsB,CAAlD,EAAK,EAAL,Ec/CyC,E,Ed+Cb,E,Ec/CkD,G,Ed+C5B,CAAlD,EAAK,EAAL,E,Ec/CiE,CA+B/D,CdWF,Cc1CP,EhBgBO,E,6DgBVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdyCL,E,EczCK,G,EdyCiB,CAAlD,EAAK,EAAL,EczCwB,E,IAAmB,E,KAAS,E,KdyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EczCwB,E,EdyCI,E,EczCwB,G,EdyCF,CAAlD,EAAK,EAAL,EczC2C,EAazC,CAbT,EhBUO,E,6DgBJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdmC1B,E,EcnC0B,G,EdmCJ,CAAlD,EAAK,EAAL,E,EcnCyC,C,IAA4B,E,KAAS,E,KdmClD,E,EAAsB,CAAlD,EAAK,EAAL,EcnCyC,E,EdmCb,E,EcnCkD,G,EdmC5B,CAAlD,EAAK,EAAL,E,EcnCiE,CAW/D,CdmBF,Cc9BP,EhBIO,E,sDiB9CM,E,Yf6EsB,E,Ee7ER,G,Ef6E8B,CAAlD,EAAK,EAAL,Ee7EM,E,EAA2C,EfwEzC,G,EAAA,GexEF,CAAb,E,EACA,E,KAAc,E,Kf4EqB,E,Ee5ErB,G,Ef4E2C,CAAlD,EAAK,EAAL,Ee5EkB,GAAzB,EjB6CO,E,sDiBvCU,E,YfsEkB,E,EetEJ,G,EfsE0B,CAAlD,EAAK,EAAL,EetEM,E,EAA4C,EfiE1C,G,EAAA,GejEF,CAAb,E,EACA,E,KAAc,E,KfqEqB,E,EerErB,G,EfqE2C,CAAlD,EAAK,EAAL,EerEkB,GAAzB,EjBsCO,E,sDiBhCM,E,Yf+DsB,E,Ee/DR,G,Ef+D8B,CAAlD,EAAK,EAAL,Ee/DM,E,EAA2C,Ef0DzC,G,EAAA,Ge1DF,CAAb,E,EACA,E,KAAc,E,Kf8DqB,E,Ee9DrB,G,Ef8D2C,CAAlD,EAAK,EAAL,Ee9DkB,GAAzB,EjB+BO,E,sDiBzBU,E,YfwDkB,E,EexDJ,G,EfwD0B,CAAlD,EAAK,EAAL,EexDM,E,EAA4C,EfmD1C,G,EAAA,GenDF,CAAb,E,EACA,E,KAAc,E,KfuDqB,E,EevDrB,G,EfuD2C,CAAlD,EAAK,EAAL,EevDkB,GAAzB,EjBwBO,E,6DiBlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KfiDJ,E,EejDI,G,EfiDkB,CAAlD,EAAK,EAAL,EejDkB,E,IAAyB,E,KAAc,E,KfiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EejD6B,G,EfiDP,CAAlD,EAAK,EAAL,EejD2C,EAAzB,IAAzB,EjBkBO,E,6DiBZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kf2CR,E,Ee3CQ,G,Ef2Cc,CAAlD,EAAK,EAAL,Ee3CkB,E,IAAkC,E,KAAc,E,Kf2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ee3CsC,G,Ef2ChB,CAAlD,EAAK,EAAL,Ee3CgD,EAA9B,IAAzB,EjBYO,E,wDkB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhByEG,E,EgBzEH,G,EhByEyB,CAAlD,EAAK,EAAL,E,EgBzEO,CAAd,E,EACA,E,KAAc,E,KhBwEqB,E,EgBxErB,G,EhBwE2C,CAAlD,EAAK,EAAL,EgBxEgC,EAAS,EAAT,ChBmEhC,CgBnEP,ElByCO,E,wDkBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBiEG,E,EgBjEH,G,EhBiEyB,CAAlD,EAAK,EAAL,E,EgBjEO,CAAd,E,EACA,E,KAAc,E,KhBgEqB,E,EgBhErB,G,EhBgE2C,CAAlD,EAAK,EAAL,EgBhEgC,EAAU,EAAV,ChB2DhC,CgB3DP,ElBiCO,E,sDkB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KhByDX,E,EgBzDW,G,EhByDW,CAAlD,EAAK,EAAL,E,EgBzDqB,CAA5B,E,EACA,E,KAAc,E,KhBwDqB,E,EgBxDrB,G,EhBwD2C,CAAlD,EAAK,EAAL,EgBxDkB,E,EAAS,CAAT,CAAzB,ElByBO,E,sDkBnBW,E,KAAc,E,KhBkDG,E,EgBlDH,G,EhBkDyB,CAAlD,EAAK,EAAL,EgBlDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhBiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgBjD0C,EAAV,ChB4ChC,CgB5CP,ElBkBO,E,sDkBZW,E,KAAc,E,KhB2CG,E,EgB3CH,G,EhB2CyB,CAAlD,EAAK,EAAL,EgB3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhB0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgB1C2C,EAAX,ChBqChC,CgBrCP,ElBWO,E,sDkBLW,E,YhBoCiB,E,EgBpCH,G,EhBoCyB,CAAlD,EAAK,EAAL,EgBpCW,E,GAAJ,CAAd,E,EAC0B,E,KhB8BX,GgB9Bf,E,EACA,E,KAAc,E,KhBkCqB,E,EgBlCrB,G,EhBkC2C,CAAlD,EAAK,EAAL,EgBlCoC,E,EAAO,C,CAAX,CAAvC,ElBGO,E,6DkBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhB2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgB3BI,G,EhB2BkB,CAAlD,EAAK,EAAL,EgB3BkB,E,EAA0B,CAA1B,CAAzB,ElBJO,E,6DkBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBpBI,G,EhBoBkB,CAAlD,EAAK,EAAL,EgBpBkB,E,EAA2B,CAA3B,CAAzB,ElBXO,E,sDkBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBaG,E,EgBbH,G,EhBayB,CAAlD,EAAK,EAAL,EgBbO,EAAd,E,EACA,E,KAAc,E,KhBYqB,E,EgBZrB,G,EhBY2C,CAAlD,EAAK,EAAL,EgBZkB,E,EAAS,CAAT,CAAzB,ElBnBO,E,sDkByBW,E,KAAc,E,KhBMG,E,EgBNH,G,EhBMyB,CAAlD,EAAK,EAAL,EgBNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBAmC,CAAzB,CAAzB,ElB1BO,E,sDkBgCW,E,KAAc,E,KhBDG,E,EgBCH,G,EhBDyB,CAAlD,EAAK,EAAL,EgBCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBOoC,CAA1B,CAAzB,ElBjCO,E,sDkBuCW,E,YhBRiB,E,EgBQH,G,EhBRyB,CAAlD,EAAK,EAAL,EgBQW,E,GAAJ,CAAd,E,EAC4B,E,KhBdb,GgBcf,E,EACA,E,KAAc,E,KhBVqB,E,EgBUrB,G,EhBV2C,CAAlD,EAAK,EAAL,EgBUoC,E,EAAS,C,CAAb,CAAvC,ElBzCO,E,wDkB+CW,E,KAAc,E,KhBhBG,E,EgBgBH,G,EhBhByB,CAAlD,EAAK,EAAL,EgBgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBjBG,E,EgBiBH,G,EhBjByB,CAAlD,EAAK,EAAL,E,EgBiBO,CAAd,E,EACA,E,KAAc,E,KhBlBqB,E,EgBkBrB,G,EhBlB2C,CAAlD,EAAK,EAAL,EgBkBgC,EAAS,EAAT,ChBvBhC,CgBuBP,ElBjDO,E,wDkBuDW,E,KAAc,E,KhBxBG,E,EgBwBH,G,EhBxByB,CAAlD,EAAK,EAAL,EgBwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBzBG,E,EgByBH,G,EhBzByB,CAAlD,EAAK,EAAL,E,EgByBO,CAAd,E,EACA,E,KAAc,E,KhB1BqB,E,EgB0BrB,G,EhB1B2C,CAAlD,EAAK,EAAL,EgB0BgC,EAAU,EAAV,ChB/BhC,CgB+BP,ElBzDO,E,sDkB+DW,E,KAAc,E,KhBhCG,E,EgBgCH,G,EhBhCyB,CAAlD,EAAK,EAAL,EgBgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KhBjCd,E,EgBiCc,G,EhBjCQ,CAAlD,EAAK,EAAL,E,EgBiCwB,CAA/B,E,EACA,E,KAAc,E,KhBlCqB,E,EgBkCrB,G,EhBlC2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ByBuB,CAAlD,EAAK,EAAL,EiBzBa,E,EAAuC,EjBoB5C,G,EAAA,G,CiBpBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YjBkBe,E,EiBlBD,G,EjBkBuB,CAAlD,EAAK,EAAL,EiBlBa,E,EAAuC,EjBa5C,G,EAAA,G,CiBbC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YjBWe,E,EiBXD,G,EjBWuB,CAAlD,EAAK,EAAL,EiBXa,E,EAAuC,EjBM5C,G,EAAA,G,CiBNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YjBIe,E,EiBJD,G,EjBIuB,CAAlD,EAAK,EAAL,EiBJa,E,EAAuC,EjBD5C,G,EAAA,G,CiBCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBFjB,GiBEG,G,OACD,E,KAAV,E,+DAKa,E,YjBHe,E,EiBGD,G,EjBHuB,CAAlD,EAAK,EAAL,EiBGa,E,EAAuC,EjBR5C,G,EAAA,G,CiBQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EjBJQ,E,EiBIoB,G,EjBJE,CAAlD,EAAK,EAAL,EiBIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YjBVe,E,EiBUD,G,EjBVuB,CAAlD,EAAK,EAAL,EiBUa,E,EAAuC,EjBf5C,G,EAAA,G,CiBeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EjBXO,E,EiBWsB,G,EjBXA,CAAlD,EAAK,EAAL,EiBWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBjBe,E,EiBiBD,G,EjBjBuB,CAAlD,EAAK,EAAL,EiBiBa,E,EAAuC,EjBtB5C,G,EAAA,G,CiBsBC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA3B,E,EjBlBO,E,EiBkBoB,G,EjBlBE,CAAlD,EAAK,EAAL,E,EiBkB8B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBxBe,E,EiBwBD,G,EjBxBuB,CAAl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ACb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,QAab,E,KAAa,E,KAAc,E,OpB9OI,E,EoB8OJ,G,EpB9O0B,CAAlD,EAAK,EAAL,EoB8OU,E,KACb,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAA2B,E,OpBrPhB,G,KoBsPX,E,KAA2B,E,OpBtPhB,G,QoByPX,E,KAAa,E,KAAc,E,OpBpPI,E,EoBoPJ,G,EpBpP0B,CAAlD,EAAK,EAAL,EoBoPU,E,KACb,E,KAAa,E,KAAc,E,OpBrPI,E,EoBqPJ,G,EpBrP0B,CAAlD,EAAK,EAAL,EoBqPU,E,KACb,E,KAAa,E,KAAc,E,OpBtPI,E,EoBsPJ,G,EpBtP0B,CAAlD,EAAK,EAAL,EoBsPU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBzMhB,G,QoB6MX,E,KAA2B,E,OpB7MhB,G,QoB2NX,E,KAAa,E,KAAc,E,OpBtNI,E,EoBsNJ,G,EpBtN0B,CAAlD,EAAK,EAAL,EoBsNU,E,KACb,E,KAA2B,E,OpB5NhB,G,QoByOX,E,KAAa,E,KAAc,E,OpBpOI,E,EoBoOJ,G,EpBpO0B,CAAlD,EAAK,EAAL,EoBoOU,E,KACb,E,KAAa,E,KAAc,E,OpBrOI,E,EoBqOJ,G,EpBrO0B,CAAlD,EAAK,EAAL,EoBqOU,E,MAbb,E,KAA2B,E,OpB7NhB,G,WoBuMJ,E,6CKnMoB,G,SACjB,E,wCnBkHkB,E,QAA9B,E,EACW,E,QAAX,E,6GbhII,EAAc,MAAd,CAAJ,EAA4E,I,iBAEvD,E,KAAJ,CAAgC,EAAhC,CAAjB,EACuD,EAA1C,E,OAIb,E,KAAc,E,oBACd,E,KAAiB,E,KACjB,E,KAAkB,E,KAClB,E,KAAe,E,iBayHC,EAAI,EAAJ,C,EACwB,EAAQ,EAAW,EAAX,CAAlC,CAAZ,E,GACyB,EAAnB,C,CAAN,E,EACY,E,KAAK,EAAY,E,GAA3B,E,KADF,GAF0B,E,GAAF,E,MAM1B,E,KAAc,EAAd,G,YmB3HsC,EAAxC,E,WACoB,GAAJ,G,IACE,E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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, Page, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getMemory(): Map {\n if (interpreter === null) {\n return new Map();\n }\n const int = interpreter;\n return int.memory.pages;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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V,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDzCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAG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,E,KAAA,G,IAAW,E,KLkBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTuIO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDS/IM,E,KAAc,E,YAAd,G,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,G,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/EgB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,EACE,E,KAAc,E,KAAA,G,IAAyB,EbyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GazDb,Gf+BK,E,6DexBH,E,KAAc,E,KbuDiB,E,EavDjB,G,EbuDuC,CAAlD,EAAK,EAAL,EavDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EatDM,G,EbsDgB,CAAlD,EAAK,EAAL,EatDoB,EAAzB,GfuBK,E,6DehBH,E,KAAc,E,Kb+CiB,E,Ea/CjB,G,Eb+CuC,CAAlD,EAAK,EAAL,Ea/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea9CM,G,Eb8CgB,CAAlD,EAAK,EAAL,Ea9CoB,EAAzB,GfeK,E,6DgB9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,Kd6EL,E,Ec7EK,G,Ed6EiB,CAAlD,EAAK,EAAL,Ec7EwB,E,IAAiC,EdwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,Ec7EwB,E,EdwEhB,GcvBN,CAjDT,EhB8CO,E,6DgBxCP,E,YAAS,G,IAAoC,E,KdkE9B,G,IclEuC,E,KAAS,E,KduE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EcvE4B,G,EduEN,CAAlD,EAAK,EAAL,EcvE+C,EA2C7C,CA3CT,EhBwCO,E,6DgBlCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdiE1B,E,EcjE0B,G,EdiEJ,CAAlD,EAAK,EAAL,E,EcjEyC,C,IAA4B,EAyCtD,G,EdwBa,E,EAAsB,CAAlD,EAAK,EAAL,EcjEyC,E,EAyC1B,GAAb,CdmBF,Cc5DP,EhBkCO,E,6DgB5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,Kd2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EcxBY,E,EdwBgB,E,Ec3DuC,G,Ed2DjB,CAAlD,EAAK,EAAL,E,Ec3DsD,CAmCpD,CdmBF,CctDP,EhB4BO,E,6DgBtBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdqDL,E,EcrDK,G,EdqDiB,CAAlD,EAAK,EAAL,EcrDwB,E,IAAmB,E,KAAS,E,KdqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EcrDwB,E,EdqDI,E,EcrDwB,G,EdqDF,CAAlD,EAAK,EAAL,EcrD2C,EAiCzC,CAjCT,EhBsBO,E,6DgBhBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,Kd+C1B,E,Ec/C0B,G,Ed+CJ,CAAlD,EAAK,EAAL,E,Ec/CyC,C,IAA4B,E,KAAS,E,Kd+ClD,E,EAAsB,CAAlD,EAAK,EAAL,Ec/CyC,E,Ed+Cb,E,Ec/CkD,G,Ed+C5B,CAAlD,EAAK,EAAL,E,Ec/CiE,CA+B/D,CdWF,Cc1CP,EhBgBO,E,6DgBVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdyCL,E,EczCK,G,EdyCiB,CAAlD,EAAK,EAAL,EczCwB,E,IAAmB,E,KAAS,E,KdyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EczCwB,E,EdyCI,E,EczCwB,G,EdyCF,CAAlD,EAAK,EAAL,EczC2C,EAazC,CAbT,EhBUO,E,6DgBJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdmC1B,E,EcnC0B,G,EdmCJ,CAAlD,EAAK,EAAL,E,EcnCyC,C,IAA4B,E,KAAS,E,KdmClD,E,EAAsB,CAAlD,EAAK,EAAL,EcnCyC,E,EdmCb,E,EcnCkD,G,EdmC5B,CAAlD,EAAK,EAAL,E,EcnCiE,CAW/D,CdmBF,Cc9BP,EhBIO,E,sDiB9CM,E,Yf6EsB,E,Ee7ER,G,Ef6E8B,CAAlD,EAAK,EAAL,Ee7EM,E,EAA2C,EfwEzC,G,EAAA,GexEF,CAAb,E,EACA,E,KAAc,E,Kf4EqB,E,Ee5ErB,G,Ef4E2C,CAAlD,EAAK,EAAL,Ee5EkB,GAAzB,EjB6CO,E,sDiBvCU,E,YfsEkB,E,EetEJ,G,EfsE0B,CAAlD,EAAK,EAAL,EetEM,E,EAA4C,EfiE1C,G,EAAA,GejEF,CAAb,E,EACA,E,KAAc,E,KfqEqB,E,EerErB,G,EfqE2C,CAAlD,EAAK,EAAL,EerEkB,GAAzB,EjBsCO,E,sDiBhCM,E,Yf+DsB,E,Ee/DR,G,Ef+D8B,CAAlD,EAAK,EAAL,Ee/DM,E,EAA2C,Ef0DzC,G,EAAA,Ge1DF,CAAb,E,EACA,E,KAAc,E,Kf8DqB,E,Ee9DrB,G,Ef8D2C,CAAlD,EAAK,EAAL,Ee9DkB,GAAzB,EjB+BO,E,sDiBzBU,E,YfwDkB,E,EexDJ,G,EfwD0B,CAAlD,EAAK,EAAL,EexDM,E,EAA4C,EfmD1C,G,EAAA,GenDF,CAAb,E,EACA,E,KAAc,E,KfuDqB,E,EevDrB,G,EfuD2C,CAAlD,EAAK,EAAL,EevDkB,GAAzB,EjBwBO,E,6DiBlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KfiDJ,E,EejDI,G,EfiDkB,CAAlD,EAAK,EAAL,EejDkB,E,IAAyB,E,KAAc,E,KfiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EejD6B,G,EfiDP,CAAlD,EAAK,EAAL,EejD2C,EAAzB,IAAzB,EjBkBO,E,6DiBZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kf2CR,E,Ee3CQ,G,Ef2Cc,CAAlD,EAAK,EAAL,Ee3CkB,E,IAAkC,E,KAAc,E,Kf2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ee3CsC,G,Ef2ChB,CAAlD,EAAK,EAAL,Ee3CgD,EAA9B,IAAzB,EjBYO,E,wDkB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhByEG,E,EgBzEH,G,EhByEyB,CAAlD,EAAK,EAAL,E,EgBzEO,CAAd,E,EACA,E,KAAc,E,KhBwEqB,E,EgBxErB,G,EhBwE2C,CAAlD,EAAK,EAAL,EgBxEgC,EAAS,EAAT,ChBmEhC,CgBnEP,ElByCO,E,wDkBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBiEG,E,EgBjEH,G,EhBiEyB,CAAlD,EAAK,EAAL,E,EgBjEO,CAAd,E,EACA,E,KAAc,E,KhBgEqB,E,EgBhErB,G,EhBgE2C,CAAlD,EAAK,EAAL,EgBhEgC,EAAU,EAAV,ChB2DhC,CgB3DP,ElBiCO,E,sDkB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KhByDX,E,EgBzDW,G,EhByDW,CAAlD,EAAK,EAAL,E,EgBzDqB,CAA5B,E,EACA,E,KAAc,E,KhBwDqB,E,EgBxDrB,G,EhBwD2C,CAAlD,EAAK,EAAL,EgBxDkB,E,EAAS,CAAT,CAAzB,ElByBO,E,sDkBnBW,E,KAAc,E,KhBkDG,E,EgBlDH,G,EhBkDyB,CAAlD,EAAK,EAAL,EgBlDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhBiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgBjD0C,EAAV,ChB4ChC,CgB5CP,ElBkBO,E,sDkBZW,E,KAAc,E,KhB2CG,E,EgB3CH,G,EhB2CyB,CAAlD,EAAK,EAAL,EgB3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhB0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgB1C2C,EAAX,ChBqChC,CgBrCP,ElBWO,E,sDkBLW,E,YhBoCiB,E,EgBpCH,G,EhBoCyB,CAAlD,EAAK,EAAL,EgBpCW,E,GAAJ,CAAd,E,EAC0B,E,KhB8BX,GgB9Bf,E,EACA,E,KAAc,E,KhBkCqB,E,EgBlCrB,G,EhBkC2C,CAAlD,EAAK,EAAL,EgBlCoC,E,EAAO,C,CAAX,CAAvC,ElBGO,E,6DkBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhB2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgB3BI,G,EhB2BkB,CAAlD,EAAK,EAAL,EgB3BkB,E,EAA0B,CAA1B,CAAzB,ElBJO,E,6DkBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBpBI,G,EhBoBkB,CAAlD,EAAK,EAAL,EgBpBkB,E,EAA2B,CAA3B,CAAzB,ElBXO,E,sDkBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBaG,E,EgBbH,G,EhBayB,CAAlD,EAAK,EAAL,EgBbO,EAAd,E,EACA,E,KAAc,E,KhBYqB,E,EgBZrB,G,EhBY2C,CAAlD,EAAK,EAAL,EgBZkB,E,EAAS,CAAT,CAAzB,ElBnBO,E,sDkByBW,E,KAAc,E,KhBMG,E,EgBNH,G,EhBMyB,CAAlD,EAAK,EAAL,EgBNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBAmC,CAAzB,CAAzB,ElB1BO,E,sDkBgCW,E,KAAc,E,KhBDG,E,EgBCH,G,EhBDyB,CAAlD,EAAK,EAAL,EgBCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBOoC,CAA1B,CAAzB,ElBjCO,E,sDkBuCW,E,YhBRiB,E,EgBQH,G,EhBRyB,CAAlD,EAAK,EAAL,EgBQW,E,GAAJ,CAAd,E,EAC4B,E,KhBdb,GgBcf,E,EACA,E,KAAc,E,KhBVqB,E,EgBUrB,G,EhBV2C,CAAlD,EAAK,EAAL,EgBUoC,E,EAAS,C,CAAb,CAAvC,ElBzCO,E,wDkB+CW,E,KAAc,E,KhBhBG,E,EgBgBH,G,EhBhByB,CAAlD,EAAK,EAAL,EgBgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBjBG,E,EgBiBH,G,EhBjByB,CAAlD,EAAK,EAAL,E,EgBiBO,CAAd,E,EACA,E,KAAc,E,KhBlBqB,E,EgBkBrB,G,EhBlB2C,CAAlD,EAAK,EAAL,EgBkBgC,EAAS,EAAT,ChBvBhC,CgBuBP,ElBjDO,E,wDkBuDW,E,KAAc,E,KhBxBG,E,EgBwBH,G,EhBxByB,CAAlD,EAAK,EAAL,EgBwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBzBG,E,EgByBH,G,EhBzByB,CAAlD,EAAK,EAAL,E,EgByBO,CAAd,E,EACA,E,KAAc,E,KhB1BqB,E,EgB0BrB,G,EhB1B2C,CAAlD,EAAK,EAAL,EgB0BgC,EAAU,EAAV,ChB/BhC,CgB+BP,ElBzDO,E,sDkB+DW,E,KAAc,E,KhBhCG,E,EgBgCH,G,EhBhCyB,CAAlD,EAAK,EAAL,EgBgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KhBjCd,E,EgBiCc,G,EhBjCQ,CAAlD,EAAK,EAAL,E,EgBiCwB,CAA/B,E,EACA,E,KAAc,E,KhBlCqB,E,EgBkCrB,G,EhBlC2C,CAAlD,EAAK,EAAL,EgBkCoC,E,EAAY,C,CAAhB,CAAvC,ElBjEO,E,6DkBuEW,E,KAAc,E,KhBxCG,E,EgBwCH,G,EhBxCyB,CAAlD,EAAK,EAAL,EgBwCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBzCJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgByCI,G,EhBzCkB,CAAlD,EAAK,EAAL,EgByCkB,E,EAA0B,CAA1B,CAAzB,ElBxEO,E,6DkB8EW,E,KAAc,E,KhB/CG,E,EgB+CH,G,EhB/CyB,CAAlD,EAAK,EAAL,EgB+CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBhDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBgDI,G,EhBhDkB,CAAlD,EAAK,EAAL,EgBgDkB,E,EAA2B,CAA3B,CAAzB,ElB/EO,E,6DkBqFW,E,KAAc,E,KhBtDG,E,EgBsDH,G,EhBtDyB,CAAlD,EAAK,EAAL,EgBsDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,KhBvDR,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBuDQ,G,EhBvDc,CAAlD,EAAK,EAAL,EgBuDkB,E,EAA+B,CAA/B,CAAzB,ElBtFO,E,mDV8HkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cACnD,E,GAAiB,E,KAAjB,CAA+B,EAAzC,G,2DQ4EY,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,E,IAAf,G,EACO,E,kEqB9PO,E,QAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,2DrBgQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,EAAQ,GAAR,CAAf,G,EACI,E,iBAAA,EAAmB,EAAnB,CAAJ,E,EACE,E,iBAAU,EAAK,E,KAAS,EAAT,CAAf,I,EAEA,E,iBAAW,EAAK,E,KAAS,EAAT,CAAhB,I,EAEK,E,kEqBrQO,E,QAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DrBuQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,EAAK,EAAI,GAAJ,CAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,EAAK,EAAI,GAAJ,CAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEqBpRO,E,QAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DrBsRO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,E,EAAK,C,IAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,E,EAAK,C,IAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEqBnSO,E,QAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBkDjB,GiBlDG,G,OACD,E,KAAV,E,+DAKO,E,KAAa,E,YAAa,E,KAAc,E,WjBiDnB,E,EiBjDmB,G,EjBiDG,CAAlD,EAAK,EAAL,EiBjDiC,EAAyB,G,CAA9B,CAArB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAc,E,KAAc,E,WjB2CrB,E,EiB3CqB,G,EjB2CC,CAAlD,EAAK,EAAL,EiB3CmC,EAAyB,I,CAA/B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAY,E,KAAc,E,WjBqCnB,E,EiBrCmB,G,EjBqCG,CAAlD,EAAK,EAAL,E,EiBrC6B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAQ,E,KAAc,E,WjB+Bf,E,EiB/Be,G,EjB+BO,CAAlD,EAAK,EAAL,EiB/B6B,EAAtB,G,OACG,E,KAAV,E,6DAKa,E,YjByBe,E,EiBzBD,G,EjByBuB,CAAlD,EAAK,EAAL,EiBzBa,E,EAAuC,EjBoB5C,G,EAAA,G,CiBpBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YjBkBe,E,EiBlBD,G,EjBkBuB,CAAlD,EAAK,EAAL,EiBlBa,E,EAAuC,EjBa5C,G,EAAA,G,CiBbC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YjBWe,E,EiBXD,G,EjBWuB,CAAlD,EAAK,EAAL,EiBXa,E,EAAuC,EjBM5C,G,EAAA,G,CiBNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YjBIe,E,EiBJD,G,EjBIuB,CAAlD,EAAK,EAAL,EiBJa,E,EAAuC,EjBD5C,G,EAAA,G,CiBCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBFjB,GiBEG,G,OACD,E,KAAV,E,+DAKa,E,YjBHe,E,EiBGD,G,EjBHuB,CAAlD,EAAK,EAAL,EiBGa,E,EAAuC,EjBR5C,G,EAAA,G,CiBQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EjBJQ,E,EiBIoB,G,EjBJE,CAAlD,EAAK,EAAL,EiBIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YjBVe,E,EiBUD,G,EjBVuB,CAAlD,EAAK,EAAL,EiBUa,E,EAAuC,EjBf5C,G,EAAA,G,CiBeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EjBXO,E,EiBWsB,G,EjBXA,CAAlD,EAAK,EAAL,EiBWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBjBe,E,EiBiBD,G,EjBjBuB,CAAlD,EAAK,EAAL,EiBiBa,E,EAAuC,EjBtB5C,G,EAAA,G,CiBsBC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA3B,E,EjBlBO,E,EiBkBoB,G,EjBlBE,CAAlD,EAAK,EAAL,E,EiBkB8B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBxBe,E,EiBwBD,G,EjBxBuB,CAAlD,E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,E,KAOmC,G,EANnC,EAMwC,G,EAAA,G,aAArB,G,wD2B5KI,E,KAAN,E,EAAY,EAA5B,G,KACT,GAAJ,E,OACS,EAAP,E,yEAfO,E,YACA,E,YACA,E,YACA,E,UACO,E,sCAehB,E,KAAmB,E,gCAEX,E,mBAOJ,E,KAA2B,E,OpB5MhB,G,QoBmNX,E,KAAa,E,KAAc,E,OpB9MI,E,EoB8MJ,G,EpB9M0B,CAAlD,EAAK,EAAL,EoB8MU,E,QAIb,E,KAAa,E,KAAc,E,OpBlNI,E,EoBkNJ,G,EpBlN0B,CAAlD,EAAK,EAAL,EoBkNU,E,KACb,E,KAAkB,E,KAAJ,GAAe,EAAf,C,IAAyB,EAAJ,G,EAArB,E,EAAqB,GAAtB,C,QAab,E,KAAa,E,KAAc,E,OpBhOI,E,EoBgOJ,G,EpBhO0B,CAAlD,EAAK,EAAL,EoBgOU,E,KACb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,QAab,E,KAAa,E,KAAc,E,OpB9OI,E,EoB8OJ,G,EpB9O0B,CAAlD,EAAK,EAAL,EoB8OU,E,KACb,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAA2B,E,OpBrPhB,G,KoBsPX,E,KAA2B,E,OpBtPhB,G,QoByPX,E,KAAa,E,KAAc,E,OpBpPI,E,EoBoPJ,G,EpBpP0B,CAAlD,EAAK,EAAL,EoBoPU,E,KACb,E,KAAa,E,KAAc,E,OpBrPI,E,EoBqPJ,G,EpBrP0B,CAAlD,EAAK,EAAL,EoBqPU,E,KACb,E,KAAa,E,KAAc,E,OpBtPI,E,EoBsPJ,G,EpBtP0B,CAAlD,EAAK,EAAL,EoBsPU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBzMhB,G,QoB6MX,E,KAA2B,E,OpB7MhB,G,QoB2NX,E,KAAa,E,KAAc,E,OpBtNI,E,EoBsNJ,G,EpBtN0B,CAAlD,EAAK,EAAL,EoBsNU,E,KACb,E,KAA2B,E,OpB5NhB,G,QoByOX,E,KAAa,E,KAAc,E,OpBpOI,E,EoBoOJ,G,EpBpO0B,CAAlD,EAAK,EAAL,EoBoOU,E,KACb,E,KAAa,E,KAAc,E,OpBrOI,E,EoBqOJ,G,EpBrO0B,CAAlD,EAAK,EAAL,EoBqOU,E,MAbb,E,KAA2B,E,OpB7NhB,G,WoBuMJ,E,6CKnMoB,G,SACjB,E,wCnBkHkB,E,QAA9B,E,EACW,E,QAAX,E,6GbhII,EAAc,MAAd,CAAJ,EAA4E,I,iBAEvD,E,KAAJ,CAAgC,EAAhC,CAAjB,EACuD,EAA1C,E,OAIb,E,KAAc,E,oBACd,E,KAAiB,E,KACjB,E,KAAkB,E,KAClB,E,KAAe,E,iBayHC,EAAI,EAAJ,C,EACwB,EAAQ,EAAW,EAAX,CAAlC,CAAZ,E,GACyB,EAAnB,C,CAAN,E,EACY,E,KAAK,EAAY,E,GAA3B,E,KADF,GAF0B,E,GAAF,E,MAM1B,E,KAAc,EAAd,G,YmB3HsC,EAAxC,E,WACoB,GAAJ,G,IACE,E,KAAM,EAAN,GAAhB,E,EACa,E,mBAAiB,EAAjB,E,OAGT,E,sBAIS,EAAR,E,IAAe,E,iBAAA,E,WAAA,EAAJ,G,IACJ,E,iBAAA,E,WAAc,EAAd,EAAV,EACA,EACM,EAAJ,E,EACE,E,iBAAuB,E,MAER,G,OACf,E,KAAuB,EAAU,EAAV,CAAsB,EAAtB,C,KACvB,E,8ChC2BiB,E,QAAnB,CAAJ,EAEiB,EAAyB,EAAW,EApH6B,EAoHhF,E,EACA,E,KAAe,E,MAER,E,KAAA,GAAiD,EAA1D,G,+BgC9Ba,EAAJ,E,EACL,E,KAAY,E,UACG,EAAf,IAZsC,E,GAAA,E,KATV,E,GAAA,E,IAyB9B,EAAJ,E,EACE,E,KAAY,E,kBAEP,E,oDA6BI,EAAX,E,EACA,EACO,EAAD,CAAJ,EACM,EAAJ,E,EAAqC,E,4BAAA,G,qBxB/C9B,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,oCwB8CR,IACN,EAAJ,E,IAAqC,E,8BAAA,G,oBAAA,K,mBxBhD9B,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,oCwB+CR,IACN,EAAJ,E,WAA+C,E,yBAAzB,G,WAAZ,IACV,GAGE,EAAJ,E,WAA8B,E,KEqChB,GADiB,EACxB,G,eFrCe,G,WAAZ,IACN,EAAJ,E,WAA+B,E,iBAAA,EEpDxB,G,eFoDe,G,WAAZ,IACN,EAAJ,E,WAAkC,E,yBAAZ,G,WAAZ,IACN,EAAJ,E,WAAqC,E,0BAAA,G,eAAf,G,WAAZ,IACN,EAAJ,E,WAAqC,E,8BAAA,G,oBAAA,G,eAAf,G,WAAZ,IACN,EAAJ,E,EACsB,E,YAAa,E,6BAAJ,E,EAAT,G,EAAwC,E,6BAAiB,E,UAAjB,GAA2B,G,IACtD,E,KADb,E,EACS,G,IAAf,GAAyC,G,EAAsB,E,EAAA,G,EAAa,EAAb,I,IAC3D,E,6BAA4C,E,UAA5C,GAAlB,E,EADc,E,UAGe,E,KAAS,E,GEf1B,CADgB,EACvB,G,qB1BhDE,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,oCwB8DlB,G,EAC8B,E,KAAY,E,6BAA0B,E,QAAS,EAAT,C,QAAA,EAA1B,E,WAAkD,E,iBAAX,E,EAApE,G,KACT,EAAJ,E,EAEF,E,OEjEc,GAAP,G,OFiEI,E,mBEuBG,GADiB,EACxB,G,OFvB+B,E,OE4CxB,GF5CyC,EE4ChD,G,OF3CP,E,OElEc,GAAP,G,OFkEI,E,mBEsBG,GADiB,EACxB,G,OFtB+B,E,OE2CxB,GF3CyC,EE2ChD,G,OF1CP,E,OEnEc,GAAP,G,OFmEI,E,mBEqBG,GADiB,EACxB,G,OFrB+B,E,OE0CxB,GF1CyC,EE0ChD,G,OFzCP,E,OEpEc,GAAP,G,OFoEI,E,mBEoBG,GADiB,EACxB,G,OFpB+B,E,OEyCxB,GFzCyC,EEyChD,G,qB1B/GE,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,oCwBiEhB,K,EAQG,E,KAAA,GAAP,E,6EA7Ie,E,oBACE,G,iCACT,E,oBACe,G,iCACd,E,YACK,E,iBA4IhB,E,KAAgB,E,eAChB,E,KAAmB,E,0ExB4DJ,E,KAhLuC,EAA7C,C,GAAwE,EAAxE,CAgLP,E,EAOU,E,KAL8C,E,SAC/C,CAAT,EAQyC,EAAc,EdrNsB,EcqNrE,G,OAES,E,KAUD,GAlBE,EACP,EAAiB,EAAjB,CAgBF,I,sCwBjFX,E,KAAY,E,eACZ,E,KAAa,E,mBAAA,E,KACb,E,KAAgC,E,iBAAhB,G,0BAChB,E,KAAkB,E,eAGlB,E,iBAAA,G,QAEO,E,sDD/FqB,E,iBAAiB,E,iBAAgB,E,0JCvEnD,E,YACC,E,iBDuEX,E,KAAc,E,KACd,E,KAAa,E,KAEA,E,8BCtBe,E,iBAAe,E,iBAAiB,E,uBAAhD,G,OACZ,E,KAAiB,E,KACjB,E,KAAa,E,eACb,E,iBAAY,E,UAAZ,E,EAEsB,E,KAAK,EAApB,G,oJtC1CU,EAAiB,EAAjB,CARE,EAU0C,EAVhD,EAAb,EAUkF,EATlF,EAAsB,EAAQ,EAAM,EAA1B,K,KAWQ,EAAmB,EAAzB,EAAZ,EACoB,EAApB,GACO,EAAO,EAA2B,EAAzC,EACa,EAAO,EAApB,GACW,EAAO,EAAlB,GACW,EAAO,EAAlB,G,OACO,E,0CcKD,EAAc,MAAd,CAAJ,EAA4E,I,cAC9D,EACsC,EAA1C,E,YAIH,E,0CJLH,EAAc,MAAd,CAAJ,EAA2D,I,cAChB,EAAe,EAA7C,E,YAIN,E,+CboSL,EAAQ,EAAR,CAAa,EAAQ,EAAR,CAAb,CAAJ,EACuB,I,aAElB,EAAD,CAAJ,E,OAAmB,IAAP,EAGR,EAAS,EAAT,CAAJ,E,EACgC,EA9NpB,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,GAoNT,EAC2C,EAAZ,CAAe,EAAxC,E,KACU,EAAwB,EAAO,EAlE1C,GAmEI,EAAS,EAAT,CAAJ,E,EACW,EAAS,EAAJ,CAAL,CAAmB,EAAnB,CAAwB,EAAzB,CAAf,EAC2C,EAAZ,CAAe,EAAxC,E,KACkC,EA3DnB,C,EAlDvB,EAAO,EAAU,EAAV,C,EAGH,EAFF,EAAU,E,CAAV,EAEsB,EAAV,CAAV,C,EACkB,CAAa,GAAb,CAAsB,EAAvB,CAAP,KAAV,GAFF,GAIA,EAAQ,E,CAAR,E,IAEE,EAAS,EAAT,CAAJ,EACa,E,EAAyB,CAAc,EAAd,CAAP,KAAV,GAAnB,K,MAsGyB,C,EAAO,EA5O3B,CAAoB,EAApB,CAwCP,EACU,EAAc,E,CAAT,CAAL,CAAuB,EAAc,EAAT,CAAL,CAAxB,CAA+C,EAA/C,CAAP,G,EAEQ,CAAe,E,EAAc,E,EACvC,EAAc,EAAP,G,EACL,EAAO,E,CAAP,EACA,EAAK,E,CAAL,EACA,EAAM,E,CAAN,E,IAEF,EAAO,EAAO,EAAP,C,EACL,EAAO,E,CAAP,EACA,E,GAAA,E,IAEK,EAAI,EAAJ,EAuLL,EAC2C,EAAZ,CAAe,EAAxC,E,KACU,E,EAAwB,CAAO,EAAU,EAAzD,I,OAEK,E,+CAgCH,EAAQ,EAAR,CAAa,EAAQ,EAAR,CAAb,CAAJ,EACuB,I,aAElB,EAAD,CAAJ,E,OAAmB,IAAP,EAGR,EAAS,EAAT,CAAJ,EACM,E,MAAA,CAAJ,E,IACiB,CAlRf,EAAQ,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,GAyQP,EAC2C,EAAZ,CAAe,EAAxC,E,KACU,EAAwB,EAAO,EAvH5C,G,EAyH+B,EArQ1B,SAAR,CAAJ,EACM,EAAQ,OAAR,CAAJ,EACkB,EAAS,OAAb,CAAL,GAAsC,EAAS,MAAb,CAAlC,EAES,EAAS,QAAb,CAAL,GAAyC,EAAS,QAAb,CAArC,GAGL,EAAQ,UAAR,CAAJ,EACkB,EAAS,SAAb,CAAL,IAES,EAAS,WAAb,CAAL,GAA8C,EAAS,UAAb,CAA1C,GA2PP,EAC2C,EAAZ,CAAe,EAAxC,E,KACU,EAAwB,EAAO,EAvG5C,IAyGI,EAAS,EAAT,CAAJ,E,EACW,EAAa,E,CAAR,CAAL,CAAwB,EAAxB,CAA6B,EAA9B,CAAf,EAC2C,EAAZ,CAAe,EAAxC,E,KAtKR,EAAO,EAAU,EAAV,C,EAGH,EAFF,EAAU,E,CAAV,EAEsB,EAAV,CAAV,C,EACkB,CAAa,GAAb,CAAsB,EAAvB,CAAP,KAAV,GAFF,GAIA,EAAQ,E,CAAR,E,IAEE,EAAS,EAAT,CAAJ,EACa,E,EAAyB,CAAc,EAAd,CAAP,KAAV,GAAnB,K,IAgKyB,E,EAAO,EAtS3B,CAAoB,EAApB,CAwCP,EACU,EAAc,E,CAAT,CAAL,CAAuB,EAAc,EAAT,CAAL,CAAxB,CAA+C,EAA/C,CAAP,G,EAEQ,CAAe,E,EAAc,E,EACvC,EAAO,EAAO,EAAP,C,EACL,EAAO,E,CAAP,EACA,EAAK,E,CAAL,EACA,EAAM,E,CAAN,E,IAEF,EAAO,EAAO,EAAP,C,EACL,EAAO,E,CAAP,EACA,E,GAAA,E,IAEK,EAAI,EAAJ,EAiPL,EAC2C,EAAZ,CAAe,EAAxC,E,KACU,EAAwB,EAAO,EAAU,EAAzD,I,OAEK,E,0CiBvXD,EAAc,KAAd,CAAJ,EAA4E,I,cAC9D,EAAiB,EAAjB,CACsC,EAA1C,E,YAIH,E,6CjBwXJ,EAAD,CAAJ,E,OAAmB,IAAP,E,EAGO,EAAD,C,EADH,EAAU,E,CAAd,CAAqB,EAArB,CAAX,EACA,CAAU,EAIU,MAAd,CAAJ,E,IACiB,CAnTf,EAAQ,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,GAVX,EAqTgD,EAAZ,CAAiB,EAAlB,CAAwB,EAAjD,E,KACmC,EAAzB,GAA+B,EAAO,EAxJnD,G,EA0J+B,EAtS1B,SAAR,CAAJ,EACM,EAAQ,OAAR,CAAJ,EACkB,EAAS,OAAb,CAAL,GAAsC,EAAS,MAAb,CAAlC,EAES,EAAS,QAAb,CAAL,GAAyC,EAAS,QAAb,CAArC,GAGL,EAAQ,UAAR,CAAJ,EACkB,EAAS,SAAb,CAAL,IAES,EAAS,WAAb,CAAL,GAA8C,EAAS,UAAb,CAA1C,GAVX,EAuSgD,EAAZ,CAAiB,EAAlB,CAAwB,EAAjD,E,KACmC,EAAzB,GAA+B,EAAO,EAxInD,GAmJH,EAAJ,EAAqB,EAAwB,EAAnC,I,OACH,E,gH4CncY,E,KAAA,EAAnB,E,EACuB,E,OAAV,G,SACwB,CAAb,G,OAEY,E,OAAA,EAAJ,EAAJ,CAAiC,EAAjC,C,IAA8C,K,EAAA,GAA9C,GAAf,E,OACb,E,KAAK,EAAK,EAAV,G,EACA,E,KAAK,EAAK,EAAV,GACa,EAAb,E,IACoB,E,KAAA,EAAJ,G,IACd,E,KAAe,E,KAAV,E,EAA0B,EAAhB,EAAf,GACA,E,GAAA,EAF0C,E,GAAA,E,QAIxB,E,KAAA,EAAJ,G,IACd,E,KAAe,E,KAAV,E,EAAmB,EAAT,EAAf,GACA,E,GAAA,EAFmC,E,GAAA,E,IAIxB,EAAR,E,IAAe,E,KAAA,GAAJ,G,IACd,E,KAAe,E,KAAV,E,EAAe,EAAL,GAAf,GACA,E,GAAA,EAF+B,E,GAAA,E,mHLZqE,E,4CACzF,I,EAA+C,E,KAAV,G,WAAvB,G,iBAA4D,EAAV,G,EAAA,I,OAEzD,E,OAAgB,E,KAAV,G,aAAhB,K,KACkB,E,iBAAW,E,iBAAa,E,uBAAxC,G,gBACC,E,KACb,E,iBAAY,EAAZ,EAEI,EAAJ,E,YACG,E,qCAAD,IAGY,EAAd,E,sHAGuG,E,4CAC1F,I,EAA+C,E,KAAV,G,WAAvB,G,iBAA4D,EAAV,G,EAAA,IAAhE,E,KAEI,E,OAAP,G,OACmC,EAAhB,G,OACf,E,KAAW,E,OAAzB,G,IAC4B,E,KAAG,E,kCFFsC,G,WAA0B,EAA1B,K,wDEGrE,E,iBAAY,EAAZ,EAEI,EAAJ,E,YACG,E,qCAAD,IAGY,EAAd,E,yIASuB,E,qIA2HnB,E,gBAGQ,E,iBAAA,E,KACE,E,iBAAe,E,OAA7B,I,4FA8BI,E,gBAGQ,E,iBAAA,E,KACU,E,KAAA,EAAV,GAAZ,EACa,EAAR,E,EAAiB,EAAI,EAAJ,C,IAEpB,E,iBAAoB,E,KAAH,E,EAAQ,EAAI,EAAJ,CAAL,E,IAFS,E,GAAA,E,sUC9Hb,E,GACI,E,GACN,E,GACM,E","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/release.wat b/build/release.wat index 8c9f3aa..e4437ad 100644 --- a/build/release.wat +++ b/build/release.wat @@ -2,8 +2,8 @@ (type $0 (func (param i32 i32 i32) (result i32))) (type $1 (func (param i32 i32) (result i32))) (type $2 (func (param i32) (result i32))) - (type $3 (func (result i32))) - (type $4 (func (param i32))) + (type $3 (func (param i32))) + (type $4 (func (result i32))) (type $5 (func (param i32 i32 i32))) (type $6 (func (param i32 i32))) (type $7 (func (param i32 i32 i32 i32) (result i32))) @@ -11,15 +11,15 @@ (type $9 (func (param i32 i32 i32 i32))) (type $10 (func (param i32 i32 i64))) (type $11 (func (param i32 i64) (result i32))) - (type $12 (func (param i64) (result i32))) - (type $13 (func (param i32 i32 i32 i32 i64 i32))) - (type $14 (func (param i32 i32 i32 i32 i32 i32 i32) (result i32))) - (type $15 (func (param i64 i32 i32) (result i32))) - (type $16 (func (param i32 i64 i32 i32 i32) (result i32))) - (type $17 (func (param i32 i64 i32 i32))) - (type $18 (func (param i32 i64 i32))) - (type $19 (func (param i32 i64))) - (type $20 (func (param i32) (result i64))) + (type $12 (func (param i32 i64))) + (type $13 (func (param i32) (result i64))) + (type $14 (func (param i64) (result i32))) + (type $15 (func (param i32 i32 i32 i32 i64 i32))) + (type $16 (func (param i32 i32 i32 i32 i32 i32 i32) (result i32))) + (type $17 (func (param i64 i32 i32) (result i32))) + (type $18 (func (param i32 i64 i32 i32 i32) (result i32))) + (type $19 (func (param i32 i64 i32 i32))) + (type $20 (func (param i32 i64 i32))) (type $21 (func (param i32 i32) (result i64))) (type $22 (func (param i32 i32 i64) (result i32))) (type $23 (func (result i64))) @@ -880,9 +880,11 @@ (export "getExitArg" (func $assembly/api-debugger/getExitArg)) (export "getGasLeft" (func $assembly/api-debugger/getGasLeft)) (export "setGasLeft" (func $assembly/api-debugger/setGasLeft)) - (export "getMemory" (func $assembly/api-debugger/getMemory)) + (export "getRegister" (func $assembly/api-debugger/getRegister)) + (export "setRegister" (func $assembly/api-debugger/setRegister)) (export "getRegisters" (func $assembly/api-debugger/getRegisters)) (export "getPageDump" (func $assembly/api-debugger/getPageDump)) + (export "getMemory" (func $assembly/api-debugger/getMemory)) (export "InputKind.Generic" (global $assembly/api-utils/InputKind.Generic)) (export "InputKind.SPI" (global $assembly/api-utils/InputKind.SPI)) (export "HasMetadata.Yes" (global $assembly/api-utils/HasMetadata.Yes)) @@ -5171,7 +5173,7 @@ select local.set $1 end - block $__inlined_func$~lib/rt/itcms/__renew$2437 + block $__inlined_func$~lib/rt/itcms/__renew$2449 local.get $4 i32.const 20 i32.sub @@ -5189,7 +5191,7 @@ i32.store offset=16 local.get $4 local.set $2 - br $__inlined_func$~lib/rt/itcms/__renew$2437 + br $__inlined_func$~lib/rt/itcms/__renew$2449 end local.get $1 local.get $3 @@ -10255,6 +10257,129 @@ i32.add global.set $~lib/memory/__stack_pointer ) + (func $assembly/memory/Memory#getPage (param $0 i32) (param $1 i32) (param $2 i32) (result i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + local.get $2 + i32.const 4095 + i32.and + local.set $3 + local.get $2 + i32.const 12 + i32.shr_u + local.tee $4 + i32.const 12 + i32.shl + local.set $5 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $2 + i32.store + block $folding-inner0 + local.get $2 + local.get $4 + call $"~lib/map/Map#has" + i32.eqz + if + local.get $5 + call $assembly/memory/fault + local.set $2 + br $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $4 + call $"~lib/map/Map#get" + local.tee $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + call $assembly/memory-page/Page#can + i32.eqz + if + global.get $~lib/memory/__stack_pointer + local.get $5 + call $assembly/memory/fault + local.tee $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + i32.const 1 + i32.store8 offset=1 + br $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + local.get $1 + local.get $0 + local.get $3 + call $assembly/memory/PageData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/EMPTY_PAGE + local.tee $0 + i32.store offset=4 + local.get $2 + local.get $0 + local.get $3 + call $assembly/memory/PageData#constructor + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) (func $~lib/typedarray/Uint8Array#fill@varargs (param $0 i32) (result i32) (local $1 i32) (local $2 i32) @@ -10437,384 +10562,267 @@ (local $5 i32) (local $6 i32) (local $7 i32) - (local $8 i32) global.get $~lib/memory/__stack_pointer i32.const 40 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner3 (result i32) - block $folding-inner2 - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21764 - i32.lt_s - br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 40 + memory.fill + block $folding-inner2 (result i32) + block $folding-inner1 + local.get $3 + i32.const 255 + i32.and + i32.eqz + if global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $3 - i32.const 255 - i32.and - i32.eqz - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $0 - i32.store - br $folding-inner2 - end + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $0 + i32.store + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + local.get $2 + call $assembly/memory/Memory#getPage + local.tee $4 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load + local.tee $5 + i32.store + local.get $5 + i32.load8_u + if global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $4 + i32.load + local.tee $0 i32.store + br $folding-inner1 + end + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.load offset=4 + local.tee $5 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + i32.load offset=8 + local.tee $4 + local.get $3 + i32.const 255 + i32.and + i32.add + local.tee $6 + i32.const 4096 + i32.le_u + if global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 - i32.lt_s - br_if $folding-inner1 + local.get $5 + i32.store offset=16 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store + local.get $5 + i32.load offset=4 + local.tee $1 + i32.store offset=8 + local.get $1 + call $assembly/memory-page/RawPage#get:data + local.set $1 global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $2 - i32.const 4095 - i32.and - local.set $5 - local.get $2 - i32.const 12 - i32.shr_u - local.tee $6 - i32.const 12 - i32.shl - local.set $7 + local.get $1 + i32.store + local.get $1 + local.get $4 + local.get $6 + call $~lib/typedarray/Uint8Array#subarray + local.tee $0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + local.tee $1 + i32.store global.get $~lib/memory/__stack_pointer local.get $0 - i32.store offset=4 + i32.store offset=8 + i32.const 2 + global.set $~argumentsLength + local.get $1 + local.get $0 + call $assembly/memory/Chunks#constructor@varargs + br $folding-inner2 + end + local.get $2 + local.get $3 + i32.const 255 + i32.and + i32.add + i64.extend_i32_u + i64.const 4294967295 + i64.and + i32.wrap_i64 + i32.const 12 + i32.shr_u + local.tee $6 + i32.const 12 + i32.shl + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.load offset=8 + local.tee $7 + i32.store + block $folding-inner0 + local.get $7 + local.get $6 + call $"~lib/map/Map#has" + i32.eqz + if + local.get $2 + call $assembly/memory/fault + local.set $0 + br $folding-inner0 + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 global.get $~lib/memory/__stack_pointer local.get $0 i32.load offset=8 - local.tee $8 + local.tee $0 i32.store - block $__inlined_func$assembly/memory/Memory#getPage$2442 (result i32) - local.get $8 - local.get $6 - call $"~lib/map/Map#has" - i32.eqz - if - local.get $7 - call $assembly/memory/fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_PAGE - local.tee $7 - i32.store offset=4 - local.get $6 - local.get $7 - local.get $5 - call $assembly/memory/PageData#constructor - br $__inlined_func$assembly/memory/Memory#getPage$2442 - end + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $6 + call $"~lib/map/Map#get" + local.tee $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + local.get $1 + call $assembly/memory-page/Page#can + i32.eqz + if global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 + local.get $2 + call $assembly/memory/fault + local.tee $0 + i32.store offset=28 global.get $~lib/memory/__stack_pointer local.get $0 - i32.load offset=8 - local.tee $8 i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - local.get $6 - call $"~lib/map/Map#get" - local.tee $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $1 - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $7 - call $assembly/memory/fault - local.tee $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 1 - i32.store8 offset=1 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_PAGE - local.tee $7 - i32.store offset=4 - local.get $6 - local.get $7 - local.get $5 - call $assembly/memory/PageData#constructor - br $__inlined_func$assembly/memory/Memory#getPage$2442 - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $7 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $7 - local.get $6 - local.get $5 - call $assembly/memory/PageData#constructor + local.get $0 + i32.const 1 + i32.store8 offset=1 + br $folding-inner0 end - local.set $5 global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer local.get $5 - i32.store offset=4 + i32.store offset=16 global.get $~lib/memory/__stack_pointer local.get $5 + i32.load offset=4 + local.tee $2 i32.store offset=8 + local.get $2 + call $assembly/memory-page/RawPage#get:data + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $4 + local.get $2 i32.store + i32.const 1 + global.set $~argumentsLength + local.get $2 local.get $4 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $0 - i32.store - br $folding-inner2 - end + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $1 + i32.store offset=32 global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $0 i32.load offset=4 - local.tee $4 - i32.store offset=12 + local.tee $0 + i32.store offset=8 + local.get $0 + call $assembly/memory-page/RawPage#get:data + local.set $0 global.get $~lib/memory/__stack_pointer - local.get $5 + local.get $0 i32.store - local.get $5 - i32.load offset=8 - local.tee $5 + local.get $0 + i32.const 0 + local.get $4 local.get $3 i32.const 255 i32.and i32.add - local.tee $6 i32.const 4096 - i32.le_u - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load offset=4 - local.tee $1 - i32.store offset=8 - local.get $1 - call $assembly/memory-page/RawPage#get:data - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $5 - local.get $6 - call $~lib/typedarray/Uint8Array#subarray - local.tee $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 2 - global.set $~argumentsLength - local.get $1 - local.get $0 - call $assembly/memory/Chunks#constructor@varargs - br $folding-inner3 - end - local.get $2 - local.get $3 - i32.const 255 - i32.and - i32.add - i64.extend_i32_u - i64.const 4294967295 - i64.and - i32.wrap_i64 - i32.const 12 - i32.shr_u + i32.sub + call $~lib/typedarray/Uint8Array#subarray + local.tee $0 + i32.store offset=36 + global.get $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT local.tee $2 - i32.const 12 - i32.shl - local.set $6 + i32.store global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $1 i32.store offset=8 global.get $~lib/memory/__stack_pointer local.get $0 - i32.load offset=8 - local.tee $7 - i32.store - block $folding-inner0 - local.get $7 - local.get $2 - call $"~lib/map/Map#has" - i32.eqz - if - local.get $6 - call $assembly/memory/fault - local.set $0 - br $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $2 - call $"~lib/map/Map#get" - local.tee $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $6 - call $assembly/memory/fault - local.tee $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store8 offset=1 - br $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load offset=4 - local.tee $2 - i32.store offset=8 - local.get $2 - call $assembly/memory-page/RawPage#get:data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - i32.const 1 - global.set $~argumentsLength - local.get $2 - local.get $5 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $1 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=8 - local.get $0 - call $assembly/memory-page/RawPage#get:data - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - local.get $5 - local.get $3 - i32.const 255 - i32.and - i32.add - i32.const 4096 - i32.sub - call $~lib/typedarray/Uint8Array#subarray - local.tee $0 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - local.get $2 - local.get $1 - local.get $0 - call $assembly/memory/Chunks#constructor - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer + i32.store offset=16 + local.get $2 + local.get $1 local.get $0 - i32.store - br $folding-inner2 + call $assembly/memory/Chunks#constructor + global.get $~lib/memory/__stack_pointer + i32.const 40 + i32.add + global.set $~lib/memory/__stack_pointer + return end - i32.const 54560 - i32.const 54608 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store end i32.const 1 global.set $~argumentsLength @@ -16816,7 +16824,7 @@ i64.const 13 i64.ge_u select - block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2447 (result i64) + block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2458 (result i64) global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 @@ -16917,7 +16925,7 @@ i64.const -1 i64.xor i64.add - br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2447 + br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2458 end local.get $3 i64.const 4294967295 @@ -27164,98 +27172,6 @@ call $~lib/builtins/abort unreachable ) - (func $"~lib/map/Map#constructor" (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21764 - i32.lt_s - if - i32.const 54560 - i32.const 54608 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.const 18 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 16 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 48 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 4 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) (func $assembly/memory-page/Arena#constructor (result i32) (local $0 i32) (local $1 i32) @@ -27526,76 +27442,157 @@ (func $assembly/memory/MemoryBuilder#constructor (result i32) (local $0 i32) (local $1 i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer i32.const 12 i32.sub global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21764 - i32.lt_s - if - i32.const 54560 - i32.const 54608 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + block $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.const 45 + call $~lib/rt/itcms/__new + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + call $~lib/object/Object#constructor + local.tee $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.const 18 + call $~lib/rt/itcms/__new + local.tee $1 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 16 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.store + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + i32.const 48 + call $~lib/arraybuffer/ArrayBuffer#constructor + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.store offset=8 + local.get $1 + local.get $2 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 4 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + local.get $1 + i32.const 0 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + call $assembly/memory-page/Arena#constructor + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $0 + local.get $1 + i32.store offset=4 + local.get $0 + local.get $1 + i32.const 0 + call $~lib/rt/itcms/__link + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $0 + return end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 45 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - call $"~lib/map/Map#constructor" - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - call $assembly/memory-page/Arena#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable ) (func $assembly/memory/MemoryBuilder#getOrCreatePageForAddress (param $0 i32) (param $1 i32) (param $2 i32) (result i32) (local $3 i32) @@ -27712,184 +27709,202 @@ i32.add global.set $~lib/memory/__stack_pointer ) + (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $0 i32) (param $1 i32) (param $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + call $~lib/typedarray/Uint8Array#get:length + local.set $3 + local.get $2 + i32.const 0 + i32.lt_s + if (result i32) + i32.const 1 + else + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $0 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + local.get $3 + i32.add + i32.lt_s + end + if + i32.const 1504 + i32.const 1744 + i32.const 1902 + i32.const 5 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=8 + local.get $2 + local.get $0 + i32.load offset=4 + i32.add + global.get $~lib/memory/__stack_pointer + local.get $1 + i32.store offset=8 + local.get $1 + i32.load offset=4 + local.get $3 + memory.copy + global.get $~lib/memory/__stack_pointer + i32.const 12 + i32.add + global.set $~lib/memory/__stack_pointer + ) (func $assembly/memory/MemoryBuilder#setData (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) - (local $8 i32) global.get $~lib/memory/__stack_pointer i32.const 24 i32.sub global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21764 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + loop $while-continue|0 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store - loop $while-continue|0 + i32.store offset=4 + local.get $3 + call $~lib/typedarray/Uint8Array#get:length + i32.const 0 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + local.get $1 + local.get $2 + call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress + local.tee $6 + i32.store offset=8 global.get $~lib/memory/__stack_pointer local.get $3 i32.store offset=4 local.get $3 call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - i32.gt_s + i32.const 4096 + local.get $2 + i32.const 4095 + i32.and + local.tee $5 + i32.sub + local.tee $4 + i32.lt_u if global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - local.get $2 - call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 local.get $3 - call $~lib/typedarray/Uint8Array#get:length - i32.const 4096 - local.get $2 - i32.const 4095 - i32.and - local.tee $7 - i32.sub - local.tee $4 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - end - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $5 - i32.store offset=16 - local.get $5 - call $assembly/memory-page/RawPage#get:data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 local.get $3 - i32.const 0 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21764 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 call $~lib/typedarray/Uint8Array#get:length - local.get $5 - local.get $7 - i32.add - i32.lt_s - if - i32.const 1504 - i32.const 1744 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $7 - local.get $6 - i32.load offset=4 - i32.add - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - i32.load offset=4 - local.get $5 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $3 - i32.store - br $while-continue|0 + local.set $4 end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $6 + i32.store offset=16 + local.get $6 + call $assembly/memory-page/RawPage#get:data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=16 + local.get $3 + i32.const 0 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=12 + local.get $6 + local.get $7 + local.get $5 + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $2 + local.get $4 + i32.add + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + i32.const 1 + global.set $~argumentsLength + global.get $~lib/memory/__stack_pointer + local.get $3 + local.get $4 + call $~lib/typedarray/Uint8Array#subarray@varargs + local.tee $3 + i32.store + br $while-continue|0 end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - return end - i32.const 54560 - i32.const 54608 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer ) (func $assembly/memory/MemoryBuilder#setEmpty (param $0 i32) (param $1 i32) (param $2 i32) global.get $~lib/memory/__stack_pointer @@ -29494,7 +29509,7 @@ i32.const 19584 call $~lib/staticarray/StaticArray<~lib/string/String>#join i32.const 19360 - i32.const 200 + i32.const 221 i32.const 5 call $~lib/builtins/abort unreachable @@ -31751,9 +31766,10 @@ i32.add global.set $~lib/memory/__stack_pointer ) - (func $assembly/api-debugger/getMemory (result i32) - (local $0 i32) - (local $1 i32) + (func $assembly/api-debugger/getRegister (param $0 i32) (result i64) + (local $1 i64) + (local $2 i32) + (local $3 i32) global.get $~lib/memory/__stack_pointer i32.const 16 i32.sub @@ -31778,19 +31794,19 @@ global.get $assembly/api-debugger/interpreter i32.eqz if - call $"~lib/map/Map#constructor" global.get $~lib/memory/__stack_pointer i32.const 16 i32.add global.set $~lib/memory/__stack_pointer + i64.const 0 return end global.get $~lib/memory/__stack_pointer global.get $assembly/api-debugger/interpreter - local.tee $0 + local.tee $2 i32.store global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $2 i32.eqz if i32.const 10512 @@ -31800,18 +31816,90 @@ call $~lib/builtins/abort unreachable end - local.get $0 + local.get $2 i32.store offset=4 global.get $~lib/memory/__stack_pointer - local.get $0 + local.get $2 i32.store offset=12 global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + local.tee $2 + i32.store offset=8 + local.get $2 local.get $0 - i32.load offset=8 - local.tee $0 + i32.const 255 + i32.and + call $~lib/staticarray/StaticArray#__get + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + ) + (func $assembly/api-debugger/setRegister (param $0 i32) (param $1 i64) + (local $2 i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + if + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + end + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $assembly/api-debugger/interpreter + i32.eqz + if + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $2 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 149 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $2 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.load offset=4 + local.tee $2 i32.store offset=8 + local.get $2 local.get $0 - i32.load offset=8 + i32.const 255 + i32.and + local.get $1 + call $~lib/staticarray/StaticArray#__set global.get $~lib/memory/__stack_pointer i32.const 16 i32.add @@ -31875,7 +31963,7 @@ if i32.const 10512 i32.const 19360 - i32.const 151 + i32.const 159 i32.const 28 call $~lib/builtins/abort unreachable @@ -31988,7 +32076,7 @@ if i32.const 10512 i32.const 19360 - i32.const 176 + i32.const 184 i32.const 28 call $~lib/builtins/abort unreachable @@ -32026,7 +32114,7 @@ i32.load offset=8 local.tee $1 i32.store - block $__inlined_func$assembly/memory/Memory#pageDump$2494 + block $__inlined_func$assembly/memory/Memory#pageDump$2505 local.get $1 local.get $0 call $"~lib/map/Map#has" @@ -32038,7 +32126,7 @@ global.set $~lib/memory/__stack_pointer i32.const 0 local.set $0 - br $__inlined_func$assembly/memory/Memory#pageDump$2494 + br $__inlined_func$assembly/memory/Memory#pageDump$2505 end global.get $~lib/memory/__stack_pointer local.get $3 @@ -32102,6 +32190,231 @@ i32.add global.set $~lib/memory/__stack_pointer ) + (func $assembly/api-debugger/getMemory (param $0 i32) (param $1 i32) (result i32) + (local $2 i32) + (local $3 i32) + (local $4 i32) + (local $5 i32) + (local $6 i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.sub + global.set $~lib/memory/__stack_pointer + block $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 28 + memory.fill + block $folding-inner0 + global.get $assembly/api-debugger/interpreter + i32.eqz + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + global.get $assembly/api-debugger/interpreter + local.tee $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.eqz + if + i32.const 10512 + i32.const 19360 + i32.const 197 + i32.const 28 + call $~lib/builtins/abort + unreachable + end + local.get $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $1 + call $~lib/typedarray/Uint8Array#constructor + local.tee $5 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.load offset=8 + local.tee $3 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + block $__inlined_func$assembly/memory/Memory#bytesRead$25 (result i32) + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.sub + global.set $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + i32.const 21764 + i32.lt_s + br_if $folding-inner1 + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 24 + memory.fill + loop $while-continue|0 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.gt_s + if + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + local.get $5 + call $~lib/typedarray/Uint8Array#get:length + local.get $2 + i32.sub + local.set $1 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.const 1 + local.get $0 + call $assembly/memory/Memory#getPage + local.tee $6 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load + local.tee $4 + i32.store + local.get $4 + i32.load8_u + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + br $__inlined_func$assembly/memory/Memory#bytesRead$25 + end + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + i32.load offset=8 + local.tee $7 + local.get $1 + i32.add + i32.const 4096 + i32.ge_u + if + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + i32.const 4096 + local.get $6 + i32.load offset=8 + i32.sub + local.set $1 + end + global.get $~lib/memory/__stack_pointer + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store offset=16 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $6 + i32.store offset=12 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.load offset=4 + local.tee $6 + i32.store offset=8 + local.get $6 + call $assembly/memory-page/RawPage#get:data + local.set $6 + global.get $~lib/memory/__stack_pointer + local.get $6 + i32.store + local.get $6 + local.get $7 + local.get $1 + local.get $7 + i32.add + call $~lib/typedarray/Uint8Array#subarray + local.tee $4 + i32.store offset=20 + global.get $~lib/memory/__stack_pointer + local.get $5 + i32.store + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $5 + local.get $4 + local.get $2 + call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> + local.get $1 + local.get $2 + i32.add + local.set $2 + local.get $0 + local.get $1 + i32.add + local.set $0 + br $while-continue|0 + end + end + global.get $~lib/memory/__stack_pointer + i32.const 24 + i32.add + global.set $~lib/memory/__stack_pointer + global.get $assembly/memory/NO_PAGE_FAULT + end + local.tee $0 + i32.store offset=24 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $0 + i32.load8_u + br_if $folding-inner0 + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $5 + return + end + i32.const 0 + call $~lib/typedarray/Uint8Array#constructor + global.get $~lib/memory/__stack_pointer + i32.const 28 + i32.add + global.set $~lib/memory/__stack_pointer + return + end + i32.const 54560 + i32.const 54608 + i32.const 1 + i32.const 1 + call $~lib/builtins/abort + unreachable + ) (func $assembly/api-utils/prepareProgram (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (result i32) (local $7 i32) (local $8 i64) @@ -33021,7 +33334,7 @@ global.get $~lib/memory/__stack_pointer i32.const 16080 i32.store - block $__inlined_func$~lib/string/String#padStart$2532 + block $__inlined_func$~lib/string/String#padStart$2543 i32.const 16076 i32.load i32.const -2 @@ -33037,7 +33350,7 @@ i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#padStart$2532 + br $__inlined_func$~lib/string/String#padStart$2543 end global.get $~lib/memory/__stack_pointer i32.const 4 @@ -33541,7 +33854,7 @@ i32.const 1 i32.shl local.set $3 - block $__inlined_func$~lib/string/String#substring$2533 + block $__inlined_func$~lib/string/String#substring$2544 local.get $2 i32.const 0 local.get $2 @@ -33562,7 +33875,7 @@ global.set $~lib/memory/__stack_pointer i32.const 15504 local.set $0 - br $__inlined_func$~lib/string/String#substring$2533 + br $__inlined_func$~lib/string/String#substring$2544 end local.get $3 i32.eqz @@ -33577,7 +33890,7 @@ i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#substring$2533 + br $__inlined_func$~lib/string/String#substring$2544 end global.get $~lib/memory/__stack_pointer local.get $4 @@ -33772,7 +34085,7 @@ local.get $0 local.get $1 i32.load - call_indirect (type $15) + call_indirect (type $17) local.tee $4 i32.store offset=8 local.get $6 @@ -36550,7 +36863,7 @@ end else global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2325 (result i32) + block $__inlined_func$~lib/util/number/ulog_base$2337 (result i32) local.get $0 i64.extend_i32_u local.set $4 @@ -36571,7 +36884,7 @@ i32.div_u i32.const 1 i32.add - br $__inlined_func$~lib/util/number/ulog_base$2325 + br $__inlined_func$~lib/util/number/ulog_base$2337 end local.get $1 i64.extend_i32_s @@ -36889,7 +37202,7 @@ end else global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2330 (result i32) + block $__inlined_func$~lib/util/number/ulog_base$2342 (result i32) local.get $0 local.set $2 local.get $1 @@ -36909,7 +37222,7 @@ i32.div_u i32.const 1 i32.add - br $__inlined_func$~lib/util/number/ulog_base$2330 + br $__inlined_func$~lib/util/number/ulog_base$2342 end local.get $1 i64.extend_i32_s @@ -37999,7 +38312,7 @@ if i32.const 10512 i32.const 19360 - i32.const 168 + i32.const 176 i32.const 28 call $~lib/builtins/abort unreachable @@ -38081,7 +38394,7 @@ if i32.const 10512 i32.const 19360 - i32.const 189 + i32.const 210 i32.const 28 call $~lib/builtins/abort unreachable From 68d9a25580f299870ebf305d09a7075b5948730a Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Tue, 14 Oct 2025 21:22:39 +0200 Subject: [PATCH 07/21] dont free memory --- assembly/api-internal.ts | 4 +--- assembly/interpreter.ts | 4 +--- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/assembly/api-internal.ts b/assembly/api-internal.ts index f5666db..353bc44 100644 --- a/assembly/api-internal.ts +++ b/assembly/api-internal.ts @@ -145,6 +145,7 @@ function executeProgram(int: Interpreter, logs: boolean = false): VmOutput { if (logs) console.log(`REGISTERS = ${int.registers.join(", ")} (final)`); if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(", ")} (final)`); if (logs) console.log(`Finished with status: ${int.status}`); + if (logs) console.log(`Exit code: ${int.exitCode}`); break; } @@ -180,8 +181,5 @@ function executeProgram(int: Interpreter, logs: boolean = false): VmOutput { output.memory = getOutputChunks(int.memory); output.exitCode = int.exitCode; - // release used pages back - int.memory.free(); - return output; } diff --git a/assembly/interpreter.ts b/assembly/interpreter.ts index 707c764..ad10af0 100644 --- a/assembly/interpreter.ts +++ b/assembly/interpreter.ts @@ -50,6 +50,7 @@ export class Interpreter { // executing right away. this.pc = this.nextPc; this.nextPc = -1; + this.exitCode = 0; } if (this.status !== Status.OK) { @@ -63,9 +64,6 @@ export class Interpreter { return true; } - // reset some stuff at start - this.exitCode = 0; - const pc = this.pc; // check if we are at the right location if (!this.program.mask.isInstruction(pc)) { From 45f434a1432ad92555b5b98619f98e58f67ef96c Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Tue, 14 Oct 2025 21:23:10 +0200 Subject: [PATCH 08/21] ananas new build --- build/debug.wasm | Bin 199136 -> 199232 bytes build/debug.wasm.map | 2 +- build/debug.wat | 166 ++-- build/release.wasm | Bin 97772 -> 97855 bytes build/release.wasm.map | 2 +- build/release.wat | 1712 ++++++++++++++++++++-------------------- 6 files changed, 959 insertions(+), 923 deletions(-) diff --git a/build/debug.wasm b/build/debug.wasm index 8e26c3e21b12a3a3aa88ce4e210376a001db7493..c109be430ebcc54bca8cdb22c3fcd34740600bd7 100644 GIT binary patch delta 796 zcma)&O-NKx6vyxXK2aNABF>DWO!2gg!bmZY&_?DFwFnGr(IRM-L4_2GkvU>73)=`8 zN+;*T86Bd9v(PMVg^Sn55G33LLQ>Nv`gn*lO*^CRoA)*?g6`&be&=w{IrnBJRC7|D z@Ag#9CsB5b>Ca{*AfXg&anN%`DUBhdJ@0wVfNu#htl~a>3}RA@c3`vwb7JQSyl>>= zG5XevJIK)0J{;vnLZtifs)#2O;?fNq=2#Z7n|O&54Mib+ZR+6=0$8D;FdBBKN?9Rm z(C;vIQ8sMC_to5gOPj@m67_-d49zQeoMCtHtqIs;9Y zA>CcThQ2Lte1VsE4lT-34AeY>D(cM1W>&1Q9~n7R^0BxhPi#rM@>U8~=~E6h=ekb) zJ;rc7`H#H$-+6ld89u%`O$(dyX_m{egzfu~aQ4srKnu5AX^zT|3+8bM^Y?o45IuR` G@Baf*mJkBvIGz`+j4i@S2dTZxf4%1C`P>3p|6h7LJ-&U}I zK^E{Gt-$XKafjdM5qw`6>F*ACehpvx9gR0I#G0& diff --git a/build/debug.wasm.map b/build/debug.wasm.map index ad5e214..0c0d1f5 100644 --- a/build/debug.wasm.map +++ b/build/debug.wasm.map @@ -1 +1 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n this.exitCode = 0;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n if (logs) console.log(`Exit code: ${int.exitCode}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/debug.wat b/build/debug.wat index 3738938..6287876 100644 --- a/build/debug.wat +++ b/build/debug.wat @@ -268,10 +268,10 @@ (global $assembly/api-utils/HasMetadata.Yes i32 (i32.const 0)) (global $assembly/api-utils/HasMetadata.No i32 (i32.const 1)) (global $~lib/builtins/u32.MAX_VALUE i32 (i32.const -1)) - (global $~lib/rt/__rtti_base i32 (i32.const 20480)) - (global $~lib/memory/__data_end i32 (i32.const 20740)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 53508)) - (global $~lib/memory/__heap_base i32 (i32.const 53508)) + (global $~lib/rt/__rtti_base i32 (i32.const 20528)) + (global $~lib/memory/__data_end i32 (i32.const 20788)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 53556)) + (global $~lib/memory/__heap_base i32 (i32.const 53556)) (memory $0 1) (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") @@ -666,25 +666,26 @@ (data $390 (i32.const 19516) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\d0K\00\00\00\00\00\00\00L\00\00") (data $391 (i32.const 19548) "\1c\00\00\00\00\00\00\00\00\00\00\00>\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") (data $392 (i32.const 19580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 \00") - (data $393 (i32.const 19644) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00P\00C\00 \00=\00 \00\00\00") - (data $394 (i32.const 19676) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00G\00A\00S\00 \00=\00 \00") - (data $395 (i32.const 19708) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $396 (i32.const 19756) "\1c\00\00\00\00\00\00\00\00\00\00\00>\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") - (data $397 (i32.const 19788) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 \00") - (data $398 (i32.const 19836) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00(\00\00\00\00\00\00\00\00\00") - (data $399 (i32.const 19868) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\14\00\00\00`M\00\00\00\00\00\00\90M\00\00\00\00\00\00@A\00\00\00\00\00\00\00\00\00\00") - (data $400 (i32.const 19916) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00") - (data $401 (i32.const 19980) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 \00\00\00") - (data $402 (i32.const 20028) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x\00") - (data $403 (i32.const 20060) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 \00\00\00") - (data $404 (i32.const 20092) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00,\00\n\00 \00 \00\00\00\00\00") - (data $405 (i32.const 20124) "|\00\00\00\03\00\00\00\00\00\00\00%\00\00\00`\00\00\00 N\00\00\00\00\00\00\90M\00\00\00\00\00\00PN\00\00\00\00\00\00pN\00\00\00\00\00\00\90M\00\00\00\00\00\00PN\00\00\00\00\00\00\90N\00\00\00\00\00\00\90M\00\00\00\00\00\00PN\00\00\00\00\00\00\90N\00\00\00\00\00\00\90M\00\00\00\00\00\00PN\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $406 (i32.const 20252) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $407 (i32.const 20284) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $408 (i32.const 20316) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $409 (i32.const 20348) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d\00\00\00") - (data $410 (i32.const 20412) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d\00\00\00\00\00") - (data $411 (i32.const 20480) "@\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\02A\00\00B\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\01\00\00\00\00\00\00\00\00\00\00$\t\00\00 \00\00\00\04A\00\00\02\01\00\00d\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00 \00\00\00\00\00\00\00\00\00\00\00 \00\00\00\02A\00\00 \00\00\00\02A\00\00\00\00\00\00\02A\00\00 \00\00\00 \00\00\00 \00\00\00\02A\00\00\02\02\00\00\10A\02\00\00\00\00\00\00\00\00\00\00\00\00\00\02A\00\00\00\00\00\00\00\00\00\00") + (data $393 (i32.const 19644) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00E\00x\00i\00t\00 \00c\00o\00d\00e\00:\00 \00\00\00\00\00\00\00") + (data $394 (i32.const 19692) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00P\00C\00 \00=\00 \00\00\00") + (data $395 (i32.const 19724) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00G\00A\00S\00 \00=\00 \00") + (data $396 (i32.const 19756) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $397 (i32.const 19804) "\1c\00\00\00\00\00\00\00\00\00\00\00>\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") + (data $398 (i32.const 19836) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 \00") + (data $399 (i32.const 19884) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00(\00\00\00\00\00\00\00\00\00") + (data $400 (i32.const 19916) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\14\00\00\00\90M\00\00\00\00\00\00\c0M\00\00\00\00\00\00@A\00\00\00\00\00\00\00\00\00\00") + (data $401 (i32.const 19964) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00") + (data $402 (i32.const 20028) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 \00\00\00") + (data $403 (i32.const 20076) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x\00") + (data $404 (i32.const 20108) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 \00\00\00") + (data $405 (i32.const 20140) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00,\00\n\00 \00 \00\00\00\00\00") + (data $406 (i32.const 20172) "|\00\00\00\03\00\00\00\00\00\00\00%\00\00\00`\00\00\00PN\00\00\00\00\00\00\c0M\00\00\00\00\00\00\80N\00\00\00\00\00\00\a0N\00\00\00\00\00\00\c0M\00\00\00\00\00\00\80N\00\00\00\00\00\00\c0N\00\00\00\00\00\00\c0M\00\00\00\00\00\00\80N\00\00\00\00\00\00\c0N\00\00\00\00\00\00\c0M\00\00\00\00\00\00\80N\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $407 (i32.const 20300) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $408 (i32.const 20332) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $409 (i32.const 20364) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $410 (i32.const 20396) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d\00\00\00") + (data $411 (i32.const 20460) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d\00\00\00\00\00") + (data $412 (i32.const 20528) "@\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\02A\00\00B\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\01\00\00\00\00\00\00\00\00\00\00$\t\00\00 \00\00\00\04A\00\00\02\01\00\00d\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00 \00\00\00\00\00\00\00\00\00\00\00 \00\00\00\02A\00\00 \00\00\00\02A\00\00\00\00\00\00\02A\00\00 \00\00\00 \00\00\00 \00\00\00\02A\00\00\02\02\00\00\10A\02\00\00\00\00\00\00\00\00\00\00\00\00\00\02A\00\00\00\00\00\00\00\00\00\00") (table $0 158 158 funcref) (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/codec~anonymous|0 $assembly/api-utils/disassemble~anonymous|0 $assembly/api-internal/executeProgram~anonymous|0 $assembly/api-internal/executeProgram~anonymous|1) (export "nextStep" (func $assembly/api-debugger/nextStep)) @@ -6526,7 +6527,7 @@ i32.const 3 i32.eq if - i32.const 20368 + i32.const 20416 i32.const 352 i32.const 338 i32.const 7 @@ -6559,7 +6560,7 @@ i32.const 3 i32.ne if - i32.const 20432 + i32.const 20480 i32.const 352 i32.const 352 i32.const 5 @@ -6716,10 +6717,10 @@ i32.const 288 local.get $0 call $~lib/rt/itcms/__visit - i32.const 20368 + i32.const 20416 local.get $0 call $~lib/rt/itcms/__visit - i32.const 20432 + i32.const 20480 local.get $0 call $~lib/rt/itcms/__visit i32.const 15488 @@ -7738,8 +7739,8 @@ global.get $~lib/memory/__data_end i32.lt_s if - i32.const 53536 i32.const 53584 + i32.const 53632 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -37313,6 +37314,14 @@ local.get $14 i32.const -1 call $assembly/interpreter/Interpreter#set:nextPc + local.get $this + local.set $14 + global.get $~lib/memory/__stack_pointer + local.get $14 + i32.store + local.get $14 + i32.const 0 + call $assembly/interpreter/Interpreter#set:exitCode end local.get $this local.set $14 @@ -37380,14 +37389,6 @@ local.get $14 i32.store local.get $14 - i32.const 0 - call $assembly/interpreter/Interpreter#set:exitCode - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 call $assembly/interpreter/Interpreter#get:pc local.set $pc local.get $this @@ -38236,7 +38237,7 @@ end i32.const 18704 i32.const 18752 - i32.const 173 + i32.const 171 i32.const 9 call $~lib/builtins/abort unreachable @@ -43466,7 +43467,7 @@ i32.store offset=12 local.get $7 call $~lib/string/String#concat - i32.const 19936 + i32.const 19984 i32.const 332 i32.const 7 call $~lib/builtins/abort @@ -43524,7 +43525,7 @@ i32.const 0 i32.const 3 i32.const 56 - i32.const 20272 + i32.const 20320 call $~lib/rt/__newArray local.set $3 global.get $~lib/memory/__stack_pointer @@ -43549,7 +43550,7 @@ i32.const 0 i32.const 2 i32.const 51 - i32.const 20304 + i32.const 20352 call $~lib/rt/__newArray local.set $3 global.get $~lib/memory/__stack_pointer @@ -44151,7 +44152,7 @@ i32.const 0 i32.const 2 i32.const 51 - i32.const 20336 + i32.const 20384 call $~lib/rt/__newArray local.tee $chunks i32.store @@ -44611,11 +44612,41 @@ local.get $25 call $~lib/console/console.log end + local.get $logs + if + i32.const 19664 + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=4 + local.get $25 + local.get $int + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=12 + local.get $25 + call $assembly/interpreter/Interpreter#get:exitCode + i32.const 10 + call $~lib/number/U32#toString + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store offset=8 + local.get $25 + call $~lib/string/String#concat + local.set $25 + global.get $~lib/memory/__stack_pointer + local.get $25 + i32.store + local.get $25 + call $~lib/console/console.log + end br $for-break0 end local.get $logs if - i32.const 19664 + i32.const 19712 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -44645,7 +44676,7 @@ end local.get $logs if - i32.const 19696 + i32.const 19744 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -44681,7 +44712,7 @@ end local.get $logs if - i32.const 19728 + i32.const 19776 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -44769,7 +44800,7 @@ local.get $25 i32.store offset=24 local.get $25 - i32.const 19776 + i32.const 19824 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -44927,7 +44958,7 @@ call $~lib/number/U8#toString local.tee $10 i32.store offset=48 - i32.const 19888 + i32.const 19936 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -44941,7 +44972,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 19888 + i32.const 19936 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -44955,7 +44986,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 19888 + i32.const 19936 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45201,7 +45232,7 @@ call $~lib/number/U64#toString local.tee $23 i32.store offset=100 - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45215,7 +45246,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45229,7 +45260,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45243,7 +45274,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45257,7 +45288,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45271,7 +45302,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45285,7 +45316,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45299,7 +45330,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45313,7 +45344,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45327,7 +45358,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45341,7 +45372,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45355,7 +45386,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45369,7 +45400,7 @@ i32.store offset=8 local.get $25 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20144 + i32.const 20192 local.set $25 global.get $~lib/memory/__stack_pointer local.get $25 @@ -45523,19 +45554,6 @@ local.get $25 call $assembly/interpreter/Interpreter#get:exitCode call $assembly/api-internal/VmOutput#set:exitCode - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/interpreter/Interpreter#get:memory - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $assembly/memory/Memory#free local.get $output local.set $25 global.get $~lib/memory/__stack_pointer diff --git a/build/release.wasm b/build/release.wasm index 4e337401b5c86b24e5ad8b75dfaf22f3757c8930..439ab36fc7ff05b498050bc555ce3067b7178c35 100644 GIT binary patch delta 9786 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\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n // reset some stuff at start\n this.exitCode = 0;\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n // release used pages back\n int.memory.free();\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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V,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDzCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAG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,E,KAAA,G,IAAW,E,KLkBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTuIO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDS/IM,E,KAAc,E,YAAd,G,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,G,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/EgB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,EACE,E,KAAc,E,KAAA,G,IAAyB,EbyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GazDb,Gf+BK,E,6DexBH,E,KAAc,E,KbuDiB,E,EavDjB,G,EbuDuC,CAAlD,EAAK,EAAL,EavDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EatDM,G,EbsDgB,CAAlD,EAAK,EAAL,EatDoB,EAAzB,GfuBK,E,6DehBH,E,KAAc,E,Kb+CiB,E,Ea/CjB,G,Eb+CuC,CAAlD,EAAK,EAAL,Ea/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea9CM,G,Eb8CgB,CAAlD,EAAK,EAAL,Ea9CoB,EAAzB,GfeK,E,6DgB9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,Kd6EL,E,Ec7EK,G,Ed6EiB,CAAlD,EAAK,EAAL,Ec7EwB,E,IAAiC,EdwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,Ec7EwB,E,EdwEhB,GcvBN,CAjDT,EhB8CO,E,6DgBxCP,E,YAAS,G,IAAoC,E,KdkE9B,G,IclEuC,E,KAAS,E,KduE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EcvE4B,G,EduEN,CAAlD,EAAK,EAAL,EcvE+C,EA2C7C,CA3CT,EhBwCO,E,6DgBlCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdiE1B,E,EcjE0B,G,EdiEJ,CAAlD,EAAK,EAAL,E,EcjEyC,C,IAA4B,EAyCtD,G,EdwBa,E,EAAsB,CAAlD,EAAK,EAAL,EcjEyC,E,EAyC1B,GAAb,CdmBF,Cc5DP,EhBkCO,E,6DgB5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,Kd2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EcxBY,E,EdwBgB,E,Ec3DuC,G,Ed2DjB,CAAlD,EAAK,EAAL,E,Ec3DsD,CAmCpD,CdmBF,CctDP,EhB4BO,E,6DgBtBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdqDL,E,EcrDK,G,EdqDiB,CAAlD,EAAK,EAAL,EcrDwB,E,IAAmB,E,KAAS,E,KdqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EcrDwB,E,EdqDI,E,EcrDwB,G,EdqDF,CAAlD,EAAK,EAAL,EcrD2C,EAiCzC,CAjCT,EhBsBO,E,6DgBhBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,Kd+C1B,E,Ec/C0B,G,Ed+CJ,CAAlD,EAAK,EAAL,E,Ec/CyC,C,IAA4B,E,KAAS,E,Kd+ClD,E,EAAsB,CAAlD,EAAK,EAAL,Ec/CyC,E,Ed+Cb,E,Ec/CkD,G,Ed+C5B,CAAlD,EAAK,EAAL,E,Ec/CiE,CA+B/D,CdWF,Cc1CP,EhBgBO,E,6DgBVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdyCL,E,EczCK,G,EdyCiB,CAAlD,EAAK,EAAL,EczCwB,E,IAAmB,E,KAAS,E,KdyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EczCwB,E,EdyCI,E,EczCwB,G,EdyCF,CAAlD,EAAK,EAAL,EczC2C,EAazC,CAbT,EhBUO,E,6DgBJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdmC1B,E,EcnC0B,G,EdmCJ,CAAlD,EAAK,EAAL,E,EcnCyC,C,IAA4B,E,KAAS,E,KdmClD,E,EAAsB,CAAlD,EAAK,EAAL,EcnCyC,E,EdmCb,E,EcnCkD,G,EdmC5B,CAAlD,EAAK,EAAL,E,EcnCiE,CAW/D,CdmBF,Cc9BP,EhBIO,E,sDiB9CM,E,Yf6EsB,E,Ee7ER,G,Ef6E8B,CAAlD,EAAK,EAAL,Ee7EM,E,EAA2C,EfwEzC,G,EAAA,GexEF,CAAb,E,EACA,E,KAAc,E,Kf4EqB,E,Ee5ErB,G,Ef4E2C,CAAlD,EAAK,EAAL,Ee5EkB,GAAzB,EjB6CO,E,sDiBvCU,E,YfsEkB,E,EetEJ,G,EfsE0B,CAAlD,EAAK,EAAL,EetEM,E,EAA4C,EfiE1C,G,EAAA,GejEF,CAAb,E,EACA,E,KAAc,E,KfqEqB,E,EerErB,G,EfqE2C,CAAlD,EAAK,EAAL,EerEkB,GAAzB,EjBsCO,E,sDiBhCM,E,Yf+DsB,E,Ee/DR,G,Ef+D8B,CAAlD,EAAK,EAAL,Ee/DM,E,EAA2C,Ef0DzC,G,EAAA,Ge1DF,CAAb,E,EACA,E,KAAc,E,Kf8DqB,E,Ee9DrB,G,Ef8D2C,CAAlD,EAAK,EAAL,Ee9DkB,GAAzB,EjB+BO,E,sDiBzBU,E,YfwDkB,E,EexDJ,G,EfwD0B,CAAlD,EAAK,EAAL,EexDM,E,EAA4C,EfmD1C,G,EAAA,GenDF,CAAb,E,EACA,E,KAAc,E,KfuDqB,E,EevDrB,G,EfuD2C,CAAlD,EAAK,EAAL,EevDkB,GAAzB,EjBwBO,E,6DiBlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KfiDJ,E,EejDI,G,EfiDkB,CAAlD,EAAK,EAAL,EejDkB,E,IAAyB,E,KAAc,E,KfiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EejD6B,G,EfiDP,CAAlD,EAAK,EAAL,EejD2C,EAAzB,IAAzB,EjBkBO,E,6DiBZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kf2CR,E,Ee3CQ,G,Ef2Cc,CAAlD,EAAK,EAAL,Ee3CkB,E,IAAkC,E,KAAc,E,Kf2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ee3CsC,G,Ef2ChB,CAAlD,EAAK,EAAL,Ee3CgD,EAA9B,IAAzB,EjBYO,E,wDkB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhByEG,E,EgBzEH,G,EhByEyB,CAAlD,EAAK,EAAL,E,EgBzEO,CAAd,E,EACA,E,KAAc,E,KhBwEqB,E,EgBxErB,G,EhBwE2C,CAAlD,EAAK,EAAL,EgBxEgC,EAAS,EAAT,ChBmEhC,CgBnEP,ElByCO,E,wDkBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBiEG,E,EgBjEH,G,EhBiEyB,CAAlD,EAAK,EAAL,E,EgBjEO,CAAd,E,EACA,E,KAAc,E,KhBgEqB,E,EgBhErB,G,EhBgE2C,CAAlD,EAAK,EAAL,EgBhEgC,EAAU,EAAV,ChB2DhC,CgB3DP,ElBiCO,E,sDkB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KhByDX,E,EgBzDW,G,EhByDW,CAAlD,EAAK,EAAL,E,EgBzDqB,CAA5B,E,EACA,E,KAAc,E,KhBwDqB,E,EgBxDrB,G,EhBwD2C,CAAlD,EAAK,EAAL,EgBxDkB,E,EAAS,CAAT,CAAzB,ElByBO,E,sDkBnBW,E,KAAc,E,KhBkDG,E,EgBlDH,G,EhBkDyB,CAAlD,EAAK,EAAL,EgBlDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhBiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgBjD0C,EAAV,ChB4ChC,CgB5CP,ElBkBO,E,sDkBZW,E,KAAc,E,KhB2CG,E,EgB3CH,G,EhB2CyB,CAAlD,EAAK,EAAL,EgB3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhB0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgB1C2C,EAAX,ChBqChC,CgBrCP,ElBWO,E,sDkBLW,E,YhBoCiB,E,EgBpCH,G,EhBoCyB,CAAlD,EAAK,EAAL,EgBpCW,E,GAAJ,CAAd,E,EAC0B,E,KhB8BX,GgB9Bf,E,EACA,E,KAAc,E,KhBkCqB,E,EgBlCrB,G,EhBkC2C,CAAlD,EAAK,EAAL,EgBlCoC,E,EAAO,C,CAAX,CAAvC,ElBGO,E,6DkBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhB2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgB3BI,G,EhB2BkB,CAAlD,EAAK,EAAL,EgB3BkB,E,EAA0B,CAA1B,CAAzB,ElBJO,E,6DkBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBpBI,G,EhBoBkB,CAAlD,EAAK,EAAL,EgBpBkB,E,EAA2B,CAA3B,CAAzB,ElBXO,E,sDkBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBaG,E,EgBbH,G,EhBayB,CAAlD,EAAK,EAAL,EgBbO,EAAd,E,EACA,E,KAAc,E,KhBYqB,E,EgBZrB,G,EhBY2C,CAAlD,EAAK,EAAL,EgBZkB,E,EAAS,CAAT,CAAzB,ElBnBO,E,sDkByBW,E,KAAc,E,KhBMG,E,EgBNH,G,EhBMyB,CAAlD,EAAK,EAAL,EgBNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBAmC,CAAzB,CAAzB,ElB1BO,E,sDkBgCW,E,KAAc,E,KhBDG,E,EgBCH,G,EhBDyB,CAAlD,EAAK,EAAL,EgBCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBOoC,CAA1B,CAAzB,ElBjCO,E,sDkBuCW,E,YhBRiB,E,EgBQH,G,EhBRyB,CAAlD,EAAK,EAAL,EgBQW,E,GAAJ,CAAd,E,EAC4B,E,KhBdb,GgBcf,E,EACA,E,KAAc,E,KhBVqB,E,EgBUrB,G,EhBV2C,CAAlD,EAAK,EAAL,EgBUoC,E,EAAS,C,CAAb,CAAvC,ElBzCO,E,wDkB+CW,E,KAAc,E,KhBhBG,E,EgBgBH,G,EhBhByB,CAAlD,EAAK,EAAL,EgBgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBjBG,E,EgBiBH,G,EhBjByB,CAAlD,EAAK,EAAL,E,EgBiBO,CAAd,E,EACA,E,KAAc,E,KhBlBqB,E,EgBkBrB,G,EhBlB2C,CAAlD,EAAK,EAAL,EgBkBgC,EAAS,EAAT,ChBvBhC,CgBuBP,ElBjDO,E,wDkBuDW,E,KAAc,E,KhBxBG,E,EgBwBH,G,EhBxByB,CAAlD,EAAK,EAAL,EgBwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBzBG,E,EgByBH,G,EhBzByB,CAAlD,EAAK,EAAL,E,EgByBO,CAAd,E,EACA,E,KAAc,E,KhB1BqB,E,EgB0BrB,G,EhB1B2C,CAAlD,EAAK,EAAL,EgB0BgC,EAAU,EAAV,ChB/BhC,CgB+BP,ElBzDO,E,sDkB+DW,E,KAAc,E,KhBhCG,E,EgBgCH,G,EhBhCyB,CAAlD,EAAK,EAAL,EgBgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KhBjCd,E,EgBiCc,G,EhBjCQ,CAAlD,EAAK,EAAL,E,EgBiCwB,CAA/B,E,EACA,E,KAAc,E,KhBlCqB,E,EgBkCrB,G,EhBlC2C,CAAlD,EAAK,EAAL,EgBkCoC,E,EAAY,C,CAAhB,CAAvC,ElBjEO,E,6DkBuEW,E,KAAc,E,KhBxCG,E,EgBwCH,G,EhBxCyB,CAAlD,EAAK,EAAL,EgBwCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBzCJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgByCI,G,EhBzCkB,CAAlD,EAAK,EAAL,EgByCkB,E,EAA0B,CAA1B,CAAzB,ElBxEO,E,6DkB8EW,E,KAAc,E,KhB/CG,E,EgB+CH,G,EhB/CyB,CAAlD,EAAK,EAAL,EgB+CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBhDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBgDI,G,EhBhDkB,CAAlD,EAAK,EAAL,EgBgDkB,E,EAA2B,CAA3B,CAAzB,ElB/EO,E,6DkBqFW,E,KAAc,E,KhBtDG,E,EgBsDH,G,EhBtDyB,CAAlD,EAAK,EAAL,EgBsDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,KhBvDR,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBuDQ,G,EhBvDc,CAAlD,EAAK,EAAL,EgBuDkB,E,EAA+B,CAA/B,CAAzB,ElBtFO,E,mDV8HkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cACnD,E,GAAiB,E,KAAjB,CAA+B,EAAzC,G,2DQ4EY,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,E,IAAf,G,EACO,E,kEqB9PO,E,QAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,2DrBgQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,EAAQ,GAAR,CAAf,G,EACI,E,iBAAA,EAAmB,EAAnB,CAAJ,E,EACE,E,iBAAU,EAAK,E,KAAS,EAAT,CAAf,I,EAEA,E,iBAAW,EAAK,E,KAAS,EAAT,CAAhB,I,EAEK,E,kEqBrQO,E,QAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DrBuQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,EAAK,EAAI,GAAJ,CAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,EAAK,EAAI,GAAJ,CAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEqBpRO,E,QAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DrBsRO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,E,EAAK,C,IAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,E,EAAK,C,IAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEqBnSO,E,QAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBkDjB,GiBlDG,G,OACD,E,KAAV,E,+DAKO,E,KAAa,E,YAAa,E,KAAc,E,WjBiDnB,E,EiBjDmB,G,EjBiDG,CAAlD,EAAK,EAAL,EiBjDiC,EAAyB,G,CAA9B,CAArB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAc,E,KAAc,E,WjB2CrB,E,EiB3CqB,G,EjB2CC,CAAlD,EAAK,EAAL,EiB3CmC,EAAyB,I,CAA/B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAY,E,KAAc,E,WjBqCnB,E,EiBrCmB,G,EjBqCG,CAAlD,EAAK,EAAL,E,EiBrC6B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAQ,E,KAAc,E,WjB+Bf,E,EiB/Be,G,EjB+BO,CAAlD,EAAK,EAAL,EiB/B6B,EAAtB,G,OACG,E,KAAV,E,6DAKa,E,YjByBe,E,EiBzBD,G,EjByBuB,CAAlD,EAAK,EAAL,EiBzBa,E,EAAuC,EjBoB5C,G,EAAA,G,CiBpBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YjBkBe,E,EiBlBD,G,EjBkBuB,CAAlD,EAAK,EAAL,EiBlBa,E,EAAuC,EjBa5C,G,EAAA,G,CiBbC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YjBWe,E,EiBXD,G,EjBWuB,CAAlD,EAAK,EAAL,EiBXa,E,EAAuC,EjBM5C,G,EAAA,G,CiBNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YjBIe,E,EiBJD,G,EjBIuB,CAAlD,EAAK,EAAL,EiBJa,E,EAAuC,EjBD5C,G,EAAA,G,CiBCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBFjB,GiBEG,G,OACD,E,KAAV,E,+DAKa,E,YjBHe,E,EiBGD,G,EjBHuB,CAAlD,EAAK,EAAL,EiBGa,E,EAAuC,EjBR5C,G,EAAA,G,CiBQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EjBJQ,E,EiBIoB,G,EjBJE,CAAlD,EAAK,EAAL,EiBIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YjBVe,E,EiBUD,G,EjBVuB,CAAlD,EAAK,EAAL,EiBUa,E,EAAuC,EjBf5C,G,EAAA,G,CiBeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EjBXO,E,EiBWsB,G,EjBXA,CAAlD,EAAK,EAAL,EiBWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBjBe,E,EiBiBD,G,EjBjBuB,CAAlD,EAAK,EAAL,EiBiBa,E,EAAuC,EjBtB5C,G,EAAA,G,CiBsBC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA3B,E,EjBlBO,E,EiBkBoB,G,EjBlBE,CAAlD,EAAK,EAAL,E,EiBkB8B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBxBe,E,EiBwBD,G,EjBxBuB,CAAlD,E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E,KAOmC,G,EANnC,EAMwC,G,EAAA,G,aAArB,G,wD2B5KI,E,KAAN,E,EAAY,EAA5B,G,KACT,GAAJ,E,OACS,EAAP,E,yEAfO,E,YACA,E,YACA,E,YACA,E,UACO,E,sCAehB,E,KAAmB,E,gCAEX,E,mBAOJ,E,KAA2B,E,OpB5MhB,G,QoBmNX,E,KAAa,E,KAAc,E,OpB9MI,E,EoB8MJ,G,EpB9M0B,CAAlD,EAAK,EAAL,EoB8MU,E,QAIb,E,KAAa,E,KAAc,E,OpBlNI,E,EoBkNJ,G,EpBlN0B,CAAlD,EAAK,EAAL,EoBkNU,E,KACb,E,KAAkB,E,KAAJ,GAAe,EAAf,C,IAAyB,EAAJ,G,EAArB,E,EAAqB,GAAtB,C,QAab,E,KAAa,E,KAAc,E,OpBhOI,E,EoBgOJ,G,EpBhO0B,CAAlD,EAAK,EAAL,EoBgOU,E,KACb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,QAab,E,KAAa,E,KAAc,E,OpB9OI,E,EoB8OJ,G,EpB9O0B,CAAlD,EAAK,EAAL,EoB8OU,E,KACb,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAA2B,E,OpBrPhB,G,KoBsPX,E,KAA2B,E,OpBtPhB,G,QoByPX,E,KAAa,E,KAAc,E,OpBpPI,E,EoBoPJ,G,EpBpP0B,CAAlD,EAAK,EAAL,EoBoPU,E,KACb,E,KAAa,E,KAAc,E,OpBrPI,E,EoBqPJ,G,EpBrP0B,CAAlD,EAAK,EAAL,EoBqPU,E,KACb,E,KAAa,E,KAAc,E,OpBtPI,E,EoBsPJ,G,EpBtP0B,CAAlD,EAAK,EAAL,EoBsPU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBzMhB,G,QoB6MX,E,KAA2B,E,OpB7MhB,G,QoB2NX,E,KAAa,E,KAAc,E,OpBtNI,E,EoBsNJ,G,EpBtN0B,CAAlD,EAAK,EAAL,EoBsNU,E,KACb,E,KAA2B,E,OpB5NhB,G,QoByOX,E,KAAa,E,KAAc,E,OpBpOI,E,EoBoOJ,G,EpBpO0B,CAAlD,EAAK,EAAL,EoBoOU,E,KACb,E,KAAa,E,KAAc,E,OpBrOI,E,EoBqOJ,G,EpBrO0B,CAAlD,EAAK,EAAL,EoBqOU,E,MAbb,E,KAA2B,E,OpB7NhB,G,WoBuMJ,E,6CKnMoB,G,SACjB,E,wCnBkHkB,E,QAA9B,E,EACW,E,QAAX,E,6GbhII,EAAc,MAAd,CAAJ,EAA4E,I,iBAEvD,E,KAAJ,CAAgC,EAAhC,CAAjB,EACuD,EAA1C,E,OAIb,E,KAAc,E,oBACd,E,KAAiB,E,KACjB,E,KAAkB,E,KAClB,E,KAAe,E,iBayHC,EAAI,EAAJ,C,EACwB,EAAQ,EAAW,EAAX,CAAlC,CAAZ,E,GACyB,EAAnB,C,CAAN,E,EACY,E,KAAK,EAAY,E,GAA3B,E,KADF,GAF0B,E,GAAF,E,MAM1B,E,KAAc,EAAd,G,YmB3HsC,EAAxC,E,WACoB,GAAJ,G,IACE,E,KAAM,EAAN,GAAhB,E,EACa,E,mBAAiB,EAAjB,E,OAGT,E,sBAIS,EAAR,E,IAAe,E,iBAAA,E,WAAA,EAAJ,G,IACJ,E,iBAAA,E,WAAc,EAAd,EAAV,EACA,EACM,EAAJ,E,EACE,E,iBAAuB,E,MAER,G,OACf,E,KAAuB,EAAU,EAAV,CAAsB,EAAtB,C,KACvB,E,8ChC2BiB,E,QAAnB,CAAJ,EAEiB,EAAyB,EAAW,EApH6B,EAoHhF,E,EACA,E,KAAe,E,MAER,E,KAAA,GAAiD,EAA1D,G,+BgC9Ba,EAAJ,E,EACL,E,KAAY,E,UACG,EAAf,IAZsC,E,GAAA,E,KATV,E,GAAA,E,IAyB9B,EAAJ,E,EACE,E,KAAY,E,kBAEP,E,oDA6BI,EAAX,E,EACA,EACO,EAAD,CAAJ,EACM,EAAJ,E,EAAqC,E,4BAAA,G,qBxB/C9B,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,oCwB8CR,IACN,EAAJ,E,IAAqC,E,8BAAA,G,oBAAA,K,mBxBhD9B,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,oCwB+CR,IACN,EAAJ,E,WAA+C,E,yBAAzB,G,WAAZ,IACN,EAAJ,E,WAAoC,E,KEwCxB,GADiB,EACxB,G,eFxCiB,G,WAAZ,IACV,GAGE,EAAJ,E,WAA8B,E,KEoChB,GADiB,EACxB,G,eFpCe,G,WAAZ,IACN,EAAJ,E,WAA+B,E,iBAAA,EErDxB,G,eFqDe,G,WAAZ,IACN,EAAJ,E,WAAkC,E,yBAAZ,G,WAAZ,IACN,EAAJ,E,WAAqC,E,0BAAA,G,eAAf,G,WAAZ,IACN,EAAJ,E,WAAqC,E,8BAAA,G,oBAAA,G,eAAf,G,WAAZ,IACN,EAAJ,E,EACsB,E,YAAa,E,6BAAJ,E,EAAT,G,EAAwC,E,6BAAiB,E,UAAjB,GAA2B,G,IACtD,E,KADb,E,EACS,G,IAAf,GAAyC,G,EAAsB,E,EAAA,G,EAAa,EAAb,I,IAC3D,E,6BAA4C,E,UAA5C,GAAlB,E,EADc,E,UAGe,E,KAAS,E,GEhB1B,CADgB,EACvB,G,qB1BhDE,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,oCwB+DlB,G,EAC8B,E,KAAY,E,6BAA0B,E,QAAS,EAAT,C,QAAA,EAA1B,E,WAAkD,E,iBAAX,E,EAApE,G,KACT,EAAJ,E,EAEF,E,OElEc,GAAP,G,OFkEI,E,mBEsBG,GADiB,EACxB,G,OFtB+B,E,OE2CxB,GF3CyC,EE2ChD,G,OF1CP,E,OEnEc,GAAP,G,OFmEI,E,mBEqBG,GADiB,EACxB,G,OFrB+B,E,OE0CxB,GF1CyC,EE0ChD,G,OFzCP,E,OEpEc,GAAP,G,OFoEI,E,mBEoBG,GADiB,EACxB,G,OFpB+B,E,OEyCxB,GFzCyC,EEyChD,G,OFxCP,E,OErEc,GAAP,G,OFqEI,E,mBEmBG,GADiB,EACxB,G,OFnB+B,E,OEwCxB,GFxCyC,EEwChD,G,qB1B/GE,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,gBADX,I,EAAT,GAES,IAAyB,EAA0B,EADxC,E,oCwBkEhB,K,EAQG,E,KAAA,GAAP,E,6EA9Ie,E,oBACE,G,iCACT,E,oBACe,G,iCACd,E,YACK,E,iBA6IhB,E,KAAgB,E,eAChB,E,KAAmB,E,0ExB2DJ,E,KAhLuC,EAA7C,C,GAAwE,EAAxE,CAgLP,E,EAOU,E,KAL8C,E,SAC/C,CAAT,EAQyC,EAAc,EdrNsB,EcqNrE,G,OAES,E,KAUD,GAlBE,EACP,EAAiB,EAAjB,CAgBF,I,sCwBhFX,E,KAAY,E,eACZ,E,KAAa,E,mBAAA,E,KACb,E,KAAgC,E,iBAAhB,G,0BAChB,E,KAAkB,E,qBAEX,E,sDD7FqB,E,iBAAiB,E,iBAAgB,E,0JCvEnD,E,YACC,E,iBDuEX,E,KAAc,E,KACd,E,KAAa,E,KAEA,E,8BCtBe,E,iBAAe,E,iBAAiB,E,uBAAhD,G,OACZ,E,KAAiB,E,KACjB,E,KAAa,E,eACb,E,iBAAY,E,UAAZ,E,EAEsB,E,KAAK,EAApB,G,oJtC1CU,EAAiB,EAAjB,CARE,EAU0C,EAVhD,EAAb,EAUkF,EATlF,EAAsB,EAAQ,EAAM,EAA1B,K,KAWQ,EAAmB,EAAzB,EAAZ,EACoB,EAApB,GACO,EAAO,EAA2B,EAAzC,EACa,EAAO,EAApB,GACW,EAAO,EAAlB,GACW,EAAO,EAAlB,G,OACO,E,0CcKD,EAAc,MAAd,CAAJ,EAA4E,I,cAC9D,EACsC,EAA1C,E,YAIH,E,0CJLH,EAAc,MAAd,CAAJ,EAA2D,I,cAChB,EAAe,EAA7C,E,YAIN,E,+CboSL,EAAQ,EAAR,CAAa,EAAQ,EAAR,CAAb,CAAJ,EACuB,I,aAElB,EAAD,CAAJ,E,OAAmB,IAAP,EAGR,EAAS,EAAT,CAAJ,E,EACgC,EA9NpB,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,GAoNT,EAC2C,EAAZ,CAAe,EAAxC,E,KACU,EAAwB,EAAO,EAlE1C,GAmEI,EAAS,EAAT,CAAJ,E,EACW,EAAS,EAAJ,CAAL,CAAmB,EAAnB,CAAwB,EAAzB,CAAf,EAC2C,EAAZ,CAAe,EAAxC,E,KACkC,EA3DnB,C,EAlDvB,EAAO,EAAU,EAAV,C,EAGH,EAFF,EAAU,E,CAAV,EAEsB,EAAV,CAAV,C,EACkB,CAAa,GAAb,CAAsB,EAAvB,CAAP,KAAV,GAFF,GAIA,EAAQ,E,CAAR,E,IAEE,EAAS,EAAT,CAAJ,EACa,E,EAAyB,CAAc,EAAd,CAAP,KAAV,GAAnB,K,MAsGyB,C,EAAO,EA5O3B,CAAoB,EAApB,CAwCP,EACU,EAAc,E,CAAT,CAAL,CAAuB,EAAc,EAAT,CAAL,CAAxB,CAA+C,EAA/C,CAAP,G,EAEQ,CAAe,E,EAAc,E,EACvC,EAAc,EAAP,G,EACL,EAAO,E,CAAP,EACA,EAAK,E,CAAL,EACA,EAAM,E,CAAN,E,IAEF,EAAO,EAAO,EAAP,C,EACL,EAAO,E,CAAP,EACA,E,GAAA,E,IAEK,EAAI,EAAJ,EAuLL,EAC2C,EAAZ,CAAe,EAAxC,E,KACU,E,EAAwB,CAAO,EAAU,EAAzD,I,OAEK,E,+CAgCH,EAAQ,EAAR,CAAa,EAAQ,EAAR,CAAb,CAAJ,EACuB,I,aAElB,EAAD,CAAJ,E,OAAmB,IAAP,EAGR,EAAS,EAAT,CAAJ,EACM,E,MAAA,CAAJ,E,IACiB,CAlRf,EAAQ,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,GAyQP,EAC2C,EAAZ,CAAe,EAAxC,E,KACU,EAAwB,EAAO,EAvH5C,G,EAyH+B,EArQ1B,SAAR,CAAJ,EACM,EAAQ,OAAR,CAAJ,EACkB,EAAS,OAAb,CAAL,GAAsC,EAAS,MAAb,CAAlC,EAES,EAAS,QAAb,CAAL,GAAyC,EAAS,QAAb,CAArC,GAGL,EAAQ,UAAR,CAAJ,EACkB,EAAS,SAAb,CAAL,IAES,EAAS,WAAb,CAAL,GAA8C,EAAS,UAAb,CAA1C,GA2PP,EAC2C,EAAZ,CAAe,EAAxC,E,KACU,EAAwB,EAAO,EAvG5C,IAyGI,EAAS,EAAT,CAAJ,E,EACW,EAAa,E,CAAR,CAAL,CAAwB,EAAxB,CAA6B,EAA9B,CAAf,EAC2C,EAAZ,CAAe,EAAxC,E,KAtKR,EAAO,EAAU,EAAV,C,EAGH,EAFF,EAAU,E,CAAV,EAEsB,EAAV,CAAV,C,EACkB,CAAa,GAAb,CAAsB,EAAvB,CAAP,KAAV,GAFF,GAIA,EAAQ,E,CAAR,E,IAEE,EAAS,EAAT,CAAJ,EACa,E,EAAyB,CAAc,EAAd,CAAP,KAAV,GAAnB,K,IAgKyB,E,EAAO,EAtS3B,CAAoB,EAApB,CAwCP,EACU,EAAc,E,CAAT,CAAL,CAAuB,EAAc,EAAT,CAAL,CAAxB,CAA+C,EAA/C,CAAP,G,EAEQ,CAAe,E,EAAc,E,EACvC,EAAO,EAAO,EAAP,C,EACL,EAAO,E,CAAP,EACA,EAAK,E,CAAL,EACA,EAAM,E,CAAN,E,IAEF,EAAO,EAAO,EAAP,C,EACL,EAAO,E,CAAP,EACA,E,GAAA,E,IAEK,EAAI,EAAJ,EAiPL,EAC2C,EAAZ,CAAe,EAAxC,E,KACU,EAAwB,EAAO,EAAU,EAAzD,I,OAEK,E,0CiBvXD,EAAc,KAAd,CAAJ,EAA4E,I,cAC9D,EAAiB,EAAjB,CACsC,EAA1C,E,YAIH,E,6CjBwXJ,EAAD,CAAJ,E,OAAmB,IAAP,E,EAGO,EAAD,C,EADH,EAAU,E,CAAd,CAAqB,EAArB,CAAX,EACA,CAAU,EAIU,MAAd,CAAJ,E,IACiB,CAnTf,EAAQ,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,GAVX,EAqTgD,EAAZ,CAAiB,EAAlB,CAAwB,EAAjD,E,KACmC,EAAzB,GAA+B,EAAO,EAxJnD,G,EA0J+B,EAtS1B,SAAR,CAAJ,EACM,EAAQ,OAAR,CAAJ,EACkB,EAAS,OAAb,CAAL,GAAsC,EAAS,MAAb,CAAlC,EAES,EAAS,QAAb,CAAL,GAAyC,EAAS,QAAb,CAArC,GAGL,EAAQ,UAAR,CAAJ,EACkB,EAAS,SAAb,CAAL,IAES,EAAS,WAAb,CAAL,GAA8C,EAAS,UAAb,CAA1C,GAVX,EAuSgD,EAAZ,CAAiB,EAAlB,CAAwB,EAAjD,E,KACmC,EAAzB,GAA+B,EAAO,EAxInD,GAmJH,EAAJ,EAAqB,EAAwB,EAAnC,I,OACH,E,gH4CncY,E,KAAA,EAAnB,E,EACuB,E,OAAV,G,SACwB,CAAb,G,OAEY,E,OAAA,EAAJ,EAAJ,CAAiC,EAAjC,C,IAA8C,K,EAAA,GAA9C,GAAf,E,OACb,E,KAAK,EAAK,EAAV,G,EACA,E,KAAK,EAAK,EAAV,GACa,EAAb,E,IACoB,E,KAAA,EAAJ,G,IACd,E,KAAe,E,KAAV,E,EAA0B,EAAhB,EAAf,GACA,E,GAAA,EAF0C,E,GAAA,E,QAIxB,E,KAAA,EAAJ,G,IACd,E,KAAe,E,KAAV,E,EAAmB,EAAT,EAAf,GACA,E,GAAA,EAFmC,E,GAAA,E,IAIxB,EAAR,E,IAAe,E,KAAA,GAAJ,G,IACd,E,KAAe,E,KAAV,E,EAAe,EAAL,GAAf,GACA,E,GAAA,EAF+B,E,GAAA,E,mHLZqE,E,4CACzF,I,EAA+C,E,KAAV,G,WAAvB,G,iBAA4D,EAAV,G,EAAA,I,OAEzD,E,OAAgB,E,KAAV,G,aAAhB,K,KACkB,E,iBAAW,E,iBAAa,E,uBAAxC,G,gBACC,E,KACb,E,iBAAY,EAAZ,EAEI,EAAJ,E,YACG,E,qCAAD,IAGY,EAAd,E,sHAGuG,E,4CAC1F,I,EAA+C,E,KAAV,G,WAAvB,G,iBAA4D,EAAV,G,EAAA,IAAhE,E,KAEI,E,OAAP,G,OACmC,EAAhB,G,OACf,E,KAAW,E,OAAzB,G,IAC4B,E,KAAG,E,kCFFsC,G,WAA0B,EAA1B,K,wDEGrE,E,iBAAY,EAAZ,EAEI,EAAJ,E,YACG,E,qCAAD,IAGY,EAAd,E,yIASuB,E,qIA2HnB,E,gBAGQ,E,iBAAA,E,KACE,E,iBAAe,E,OAA7B,I,4FA8BI,E,gBAGQ,E,iBAAA,E,KACU,E,KAAA,EAAV,GAAZ,EACa,EAAR,E,EAAiB,EAAI,EAAJ,C,IAEpB,E,iBAAoB,E,KAAH,E,EAAQ,EAAI,EAAJ,CAAL,E,IAFS,E,GAAA,E,sUC9Hb,E,GACI,E,GACN,E,GACM,E","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n this.exitCode = 0;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n if (logs) console.log(`Exit code: ${int.exitCode}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/release.wat b/build/release.wat index e4437ad..dc9125d 100644 --- a/build/release.wat +++ b/build/release.wat @@ -51,8 +51,8 @@ (global $assembly/api-utils/InputKind.SPI i32 (i32.const 1)) (global $assembly/api-utils/HasMetadata.Yes i32 (i32.const 0)) (global $assembly/api-utils/HasMetadata.No i32 (i32.const 1)) - (global $~lib/rt/__rtti_base i32 (i32.const 21504)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 54532)) + (global $~lib/rt/__rtti_base i32 (i32.const 21552)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 54580)) (memory $0 1) (data $0 (i32.const 1036) "L") (data $0.1 (i32.const 1048) "\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03") @@ -826,50 +826,52 @@ (data $391.1 (i32.const 20584) ">\00\00\00\08\00\00\00\9c") (data $392 (i32.const 20604) "<") (data $392.1 (i32.const 20616) "\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 ") - (data $393 (i32.const 20668) "\1c") - (data $393.1 (i32.const 20680) "\02\00\00\00\n\00\00\00P\00C\00 \00=\00 ") - (data $394 (i32.const 20700) "\1c") - (data $394.1 (i32.const 20712) "\02\00\00\00\0c\00\00\00G\00A\00S\00 \00=\00 ") - (data $395 (i32.const 20732) ",") - (data $395.1 (i32.const 20744) "\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 ") - (data $396 (i32.const 20780) "\1c") - (data $396.1 (i32.const 20792) ">\00\00\00\08\00\00\00\9d") - (data $397 (i32.const 20812) ",") - (data $397.1 (i32.const 20824) "\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 ") - (data $398 (i32.const 20860) "\1c") - (data $398.1 (i32.const 20872) "\02\00\00\00\04\00\00\00 \00(") - (data $399 (i32.const 20892) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\14\00\00\00`Q\00\00\00\00\00\00\90Q\00\00\00\00\00\00@E") - (data $400 (i32.const 20940) "<") - (data $400.1 (i32.const 20952) "\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s") - (data $401 (i32.const 21004) ",") - (data $401.1 (i32.const 21016) "\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 ") - (data $402 (i32.const 21052) "\1c") - (data $402.1 (i32.const 21064) "\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x") - (data $403 (i32.const 21084) "\1c") - (data $403.1 (i32.const 21096) "\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 ") - (data $404 (i32.const 21116) "\1c") - (data $404.1 (i32.const 21128) "\02\00\00\00\08\00\00\00,\00\n\00 \00 ") - (data $405 (i32.const 21148) "|\00\00\00\03\00\00\00\00\00\00\00%\00\00\00`\00\00\00 R\00\00\00\00\00\00\90Q\00\00\00\00\00\00PR\00\00\00\00\00\00pR\00\00\00\00\00\00\90Q\00\00\00\00\00\00PR\00\00\00\00\00\00\90R\00\00\00\00\00\00\90Q\00\00\00\00\00\00PR\00\00\00\00\00\00\90R\00\00\00\00\00\00\90Q\00\00\00\00\00\00PR") - (data $406 (i32.const 21276) "\1c") - (data $406.1 (i32.const 21288) "\01") - (data $407 (i32.const 21308) "\1c") - (data $407.1 (i32.const 21320) "\01") - (data $408 (i32.const 21340) "\1c") - (data $408.1 (i32.const 21352) "\01") - (data $409 (i32.const 21372) "<") - (data $409.1 (i32.const 21384) "\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d") - (data $410 (i32.const 21436) "<") - (data $410.1 (i32.const 21448) "\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d") - (data $411 (i32.const 21504) "@\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 ") - (data $411.1 (i32.const 21564) "$\02") - (data $411.2 (i32.const 21576) "\02A\00\00\10A\02\00 ") - (data $411.3 (i32.const 21600) "d") - (data $411.4 (i32.const 21612) "\02A\00\00B") - (data $411.5 (i32.const 21636) "$\01") - (data $411.6 (i32.const 21648) "$\t\00\00 \00\00\00\04A\00\00\02\01\00\00d") - (data $411.7 (i32.const 21680) " ") - (data $411.8 (i32.const 21692) " \00\00\00\02A\00\00 \00\00\00\02A\00\00\00\00\00\00\02A\00\00 \00\00\00 \00\00\00 \00\00\00\02A\00\00\02\02\00\00\10A\02") - (data $411.9 (i32.const 21752) "\02A") + (data $393 (i32.const 20668) ",") + (data $393.1 (i32.const 20680) "\02\00\00\00\16\00\00\00E\00x\00i\00t\00 \00c\00o\00d\00e\00:\00 ") + (data $394 (i32.const 20716) "\1c") + (data $394.1 (i32.const 20728) "\02\00\00\00\n\00\00\00P\00C\00 \00=\00 ") + (data $395 (i32.const 20748) "\1c") + (data $395.1 (i32.const 20760) "\02\00\00\00\0c\00\00\00G\00A\00S\00 \00=\00 ") + (data $396 (i32.const 20780) ",") + (data $396.1 (i32.const 20792) "\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 ") + (data $397 (i32.const 20828) "\1c") + (data $397.1 (i32.const 20840) ">\00\00\00\08\00\00\00\9d") + (data $398 (i32.const 20860) ",") + (data $398.1 (i32.const 20872) "\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 ") + (data $399 (i32.const 20908) "\1c") + (data $399.1 (i32.const 20920) "\02\00\00\00\04\00\00\00 \00(") + (data $400 (i32.const 20940) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\14\00\00\00\90Q\00\00\00\00\00\00\c0Q\00\00\00\00\00\00@E") + (data $401 (i32.const 20988) "<") + (data $401.1 (i32.const 21000) "\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s") + (data $402 (i32.const 21052) ",") + (data $402.1 (i32.const 21064) "\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 ") + (data $403 (i32.const 21100) "\1c") + (data $403.1 (i32.const 21112) "\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x") + (data $404 (i32.const 21132) "\1c") + (data $404.1 (i32.const 21144) "\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 ") + (data $405 (i32.const 21164) "\1c") + (data $405.1 (i32.const 21176) "\02\00\00\00\08\00\00\00,\00\n\00 \00 ") + (data $406 (i32.const 21196) "|\00\00\00\03\00\00\00\00\00\00\00%\00\00\00`\00\00\00PR\00\00\00\00\00\00\c0Q\00\00\00\00\00\00\80R\00\00\00\00\00\00\a0R\00\00\00\00\00\00\c0Q\00\00\00\00\00\00\80R\00\00\00\00\00\00\c0R\00\00\00\00\00\00\c0Q\00\00\00\00\00\00\80R\00\00\00\00\00\00\c0R\00\00\00\00\00\00\c0Q\00\00\00\00\00\00\80R") + (data $407 (i32.const 21324) "\1c") + (data $407.1 (i32.const 21336) "\01") + (data $408 (i32.const 21356) "\1c") + (data $408.1 (i32.const 21368) "\01") + (data $409 (i32.const 21388) "\1c") + (data $409.1 (i32.const 21400) "\01") + (data $410 (i32.const 21420) "<") + (data $410.1 (i32.const 21432) "\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d") + (data $411 (i32.const 21484) "<") + (data $411.1 (i32.const 21496) "\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d") + (data $412 (i32.const 21552) "@\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 ") + (data $412.1 (i32.const 21612) "$\02") + (data $412.2 (i32.const 21624) "\02A\00\00\10A\02\00 ") + (data $412.3 (i32.const 21648) "d") + (data $412.4 (i32.const 21660) "\02A\00\00B") + (data $412.5 (i32.const 21684) "$\01") + (data $412.6 (i32.const 21696) "$\t\00\00 \00\00\00\04A\00\00\02\01\00\00d") + (data $412.7 (i32.const 21728) " ") + (data $412.8 (i32.const 21740) " \00\00\00\02A\00\00 \00\00\00\02A\00\00\00\00\00\00\02A\00\00 \00\00\00 \00\00\00 \00\00\00\02A\00\00\02\02\00\00\10A\02") + (data $412.9 (i32.const 21800) "\02A") (table $0 158 158 funcref) (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/codec~anonymous|0 $assembly/api-utils/disassemble~anonymous|0 $assembly/api-internal/executeProgram~anonymous|0 $assembly/api-internal/executeProgram~anonymous|0) (export "nextStep" (func $assembly/api-debugger/nextStep)) @@ -923,9 +925,9 @@ call $~lib/rt/itcms/__visit i32.const 1312 call $~lib/rt/itcms/__visit - i32.const 21392 + i32.const 21440 call $~lib/rt/itcms/__visit - i32.const 21456 + i32.const 21504 call $~lib/rt/itcms/__visit i32.const 16512 call $~lib/rt/itcms/__visit @@ -1022,7 +1024,7 @@ i32.load offset=8 i32.eqz local.get $0 - i32.const 54532 + i32.const 54580 i32.lt_u i32.and i32.eqz @@ -1096,7 +1098,7 @@ i32.const 1 else local.get $2 - i32.const 21504 + i32.const 21552 i32.load i32.gt_u if @@ -1110,7 +1112,7 @@ local.get $2 i32.const 2 i32.shl - i32.const 21508 + i32.const 21556 i32.add i32.load i32.const 32 @@ -1694,10 +1696,10 @@ if unreachable end - i32.const 54544 + i32.const 54592 i32.const 0 i32.store - i32.const 56112 + i32.const 56160 i32.const 0 i32.store loop $for-loop|0 @@ -1708,7 +1710,7 @@ local.get $0 i32.const 2 i32.shl - i32.const 54544 + i32.const 54592 i32.add i32.const 0 i32.store offset=4 @@ -1726,7 +1728,7 @@ i32.add i32.const 2 i32.shl - i32.const 54544 + i32.const 54592 i32.add i32.const 0 i32.store offset=96 @@ -1744,14 +1746,14 @@ br $for-loop|0 end end - i32.const 54544 - i32.const 56116 + i32.const 54592 + i32.const 56164 memory.size i64.extend_i32_s i64.const 16 i64.shl call $~lib/rt/tlsf/addMemory - i32.const 54544 + i32.const 54592 global.set $~lib/rt/tlsf/ROOT ) (func $~lib/rt/itcms/step (result i32) @@ -1836,7 +1838,7 @@ local.set $0 loop $while-continue|0 local.get $0 - i32.const 54532 + i32.const 54580 i32.lt_u if local.get $0 @@ -1932,7 +1934,7 @@ unreachable end local.get $0 - i32.const 54532 + i32.const 54580 i32.lt_u if local.get $0 @@ -1955,7 +1957,7 @@ i32.const 4 i32.add local.tee $0 - i32.const 54532 + i32.const 54580 i32.ge_u if global.get $~lib/rt/tlsf/ROOT @@ -2572,11 +2574,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -2804,11 +2806,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3151,7 +3153,7 @@ i32.const 3 i32.eq if - i32.const 21392 + i32.const 21440 i32.const 1376 i32.const 338 i32.const 7 @@ -3204,7 +3206,7 @@ i32.const 3 i32.ne if - i32.const 21456 + i32.const 21504 i32.const 1376 i32.const 352 i32.const 5 @@ -3293,11 +3295,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3334,11 +3336,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3404,11 +3406,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3438,11 +3440,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3684,7 +3686,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner8 global.get $~lib/memory/__stack_pointer @@ -3697,7 +3699,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner8 global.get $~lib/memory/__stack_pointer @@ -3745,7 +3747,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner8 global.get $~lib/memory/__stack_pointer @@ -3800,8 +3802,8 @@ call $~lib/rt/itcms/__visit return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3827,7 +3829,7 @@ memory.size i32.const 16 i32.shl - i32.const 54532 + i32.const 54580 i32.sub i32.const 1 i32.shr_u @@ -3862,11 +3864,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3903,11 +3905,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -3967,11 +3969,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4020,11 +4022,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4052,11 +4054,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4168,11 +4170,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4216,11 +4218,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4332,11 +4334,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4370,7 +4372,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -4382,7 +4384,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -4445,8 +4447,8 @@ local.get $2 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4460,11 +4462,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4523,11 +4525,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4554,11 +4556,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4602,11 +4604,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4649,11 +4651,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4707,11 +4709,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4777,11 +4779,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4848,11 +4850,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4897,11 +4899,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -4952,11 +4954,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -5036,11 +5038,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -5102,11 +5104,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -5173,7 +5175,7 @@ select local.set $1 end - block $__inlined_func$~lib/rt/itcms/__renew$2449 + block $__inlined_func$~lib/rt/itcms/__renew$2450 local.get $4 i32.const 20 i32.sub @@ -5191,7 +5193,7 @@ i32.store offset=16 local.get $4 local.set $2 - br $__inlined_func$~lib/rt/itcms/__renew$2449 + br $__inlined_func$~lib/rt/itcms/__renew$2450 end local.get $1 local.get $3 @@ -5240,11 +5242,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -5310,11 +5312,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7113,11 +7115,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7174,7 +7176,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -7195,7 +7197,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -7291,8 +7293,8 @@ local.get $1 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7305,11 +7307,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7359,11 +7361,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7413,11 +7415,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7462,11 +7464,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7516,11 +7518,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7586,11 +7588,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7651,11 +7653,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7718,11 +7720,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7783,11 +7785,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7850,11 +7852,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7915,11 +7917,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -7982,11 +7984,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8049,11 +8051,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8116,11 +8118,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8184,11 +8186,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8272,11 +8274,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8315,11 +8317,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8380,11 +8382,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8445,11 +8447,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8510,11 +8512,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8575,11 +8577,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8640,11 +8642,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8704,11 +8706,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8766,11 +8768,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8828,11 +8830,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8890,11 +8892,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -8953,11 +8955,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9030,11 +9032,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9107,11 +9109,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9184,11 +9186,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9261,11 +9263,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9338,11 +9340,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9413,11 +9415,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9444,11 +9446,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9486,11 +9488,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9536,11 +9538,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9590,11 +9592,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9664,11 +9666,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9723,11 +9725,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9772,11 +9774,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9846,11 +9848,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9909,11 +9911,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -9982,11 +9984,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10043,11 +10045,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10110,11 +10112,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10151,11 +10153,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10221,11 +10223,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10266,11 +10268,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10391,7 +10393,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -10418,7 +10420,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -10471,8 +10473,8 @@ local.get $0 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10485,11 +10487,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10567,11 +10569,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10842,11 +10844,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10902,11 +10904,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -10957,7 +10959,7 @@ block $folding-inner1 block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -11001,7 +11003,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -11056,7 +11058,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -11157,8 +11159,8 @@ local.set $0 br $folding-inner1 end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11178,11 +11180,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11241,11 +11243,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11287,11 +11289,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11376,11 +11378,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11446,11 +11448,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11533,11 +11535,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11624,11 +11626,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11712,11 +11714,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11829,11 +11831,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -11916,11 +11918,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12023,11 +12025,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12111,11 +12113,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12282,11 +12284,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12370,11 +12372,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12504,11 +12506,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12592,11 +12594,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12871,11 +12873,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -12959,11 +12961,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13068,11 +13070,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13177,11 +13179,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13286,11 +13288,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13395,11 +13397,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13504,11 +13506,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13613,11 +13615,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13722,11 +13724,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13795,11 +13797,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13868,11 +13870,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -13941,11 +13943,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14026,11 +14028,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14111,11 +14113,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14196,11 +14198,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14283,11 +14285,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14370,11 +14372,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14458,11 +14460,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14530,11 +14532,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14604,11 +14606,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14676,11 +14678,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14745,11 +14747,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14818,11 +14820,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14887,11 +14889,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -14973,11 +14975,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15063,11 +15065,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15149,11 +15151,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15257,11 +15259,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15392,11 +15394,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15501,11 +15503,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15638,11 +15640,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15723,11 +15725,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15808,11 +15810,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -15893,11 +15895,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16018,11 +16020,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16151,11 +16153,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16293,11 +16295,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16432,11 +16434,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16656,11 +16658,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16792,11 +16794,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -16824,7 +16826,7 @@ i64.const 13 i64.ge_u select - block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2458 (result i64) + block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2459 (result i64) global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=4 @@ -16925,7 +16927,7 @@ i64.const -1 i64.xor i64.add - br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2458 + br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2459 end local.get $3 i64.const 4294967295 @@ -16991,11 +16993,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17078,11 +17080,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17165,11 +17167,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17252,11 +17254,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17337,7 +17339,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -17354,7 +17356,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -17393,8 +17395,8 @@ local.get $0 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17406,11 +17408,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17435,11 +17437,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17467,7 +17469,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -17502,7 +17504,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -17619,8 +17621,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -17643,7 +17645,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -17753,7 +17755,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -18014,8 +18016,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18034,7 +18036,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -18071,7 +18073,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -18267,8 +18269,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18281,11 +18283,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18345,11 +18347,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18414,11 +18416,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18484,11 +18486,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18568,11 +18570,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18654,11 +18656,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18727,11 +18729,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18800,11 +18802,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18874,11 +18876,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -18949,11 +18951,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19034,11 +19036,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19122,11 +19124,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19207,11 +19209,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19294,11 +19296,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19363,11 +19365,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19432,11 +19434,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19501,11 +19503,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19571,11 +19573,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19657,11 +19659,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19743,11 +19745,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19818,11 +19820,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19893,11 +19895,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -19967,11 +19969,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20040,11 +20042,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20114,11 +20116,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20189,11 +20191,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20264,11 +20266,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20340,11 +20342,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20413,11 +20415,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20486,11 +20488,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20560,11 +20562,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20636,11 +20638,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20724,11 +20726,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20812,11 +20814,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20900,11 +20902,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -20988,11 +20990,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21076,11 +21078,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21163,11 +21165,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21211,11 +21213,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21290,11 +21292,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21344,11 +21346,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21470,11 +21472,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21526,11 +21528,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21673,11 +21675,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21727,11 +21729,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21876,11 +21878,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21930,11 +21932,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -21999,11 +22001,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22068,11 +22070,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22135,11 +22137,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22200,11 +22202,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22274,11 +22276,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22348,11 +22350,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22420,11 +22422,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22493,11 +22495,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22581,11 +22583,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22669,11 +22671,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22755,11 +22757,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22838,11 +22840,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22887,11 +22889,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -22952,11 +22954,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23002,11 +23004,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23064,11 +23066,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23127,11 +23129,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23200,11 +23202,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23238,11 +23240,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23452,11 +23454,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23494,11 +23496,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23556,11 +23558,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23605,11 +23607,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23670,11 +23672,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23786,11 +23788,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -23844,11 +23846,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -24205,11 +24207,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -24515,11 +24517,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -24572,7 +24574,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -24593,7 +24595,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -24802,8 +24804,8 @@ local.get $4 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -24823,7 +24825,7 @@ block $folding-inner2 block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner2 global.get $~lib/memory/__stack_pointer @@ -24872,7 +24874,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner00 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner00 global.get $~lib/memory/__stack_pointer @@ -24897,7 +24899,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner00 global.get $~lib/memory/__stack_pointer @@ -25003,7 +25005,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner2 global.get $~lib/memory/__stack_pointer @@ -25176,8 +25178,8 @@ local.get $3 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -25193,7 +25195,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -25222,7 +25224,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -25281,8 +25283,8 @@ local.get $1 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -25295,11 +25297,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -25350,11 +25352,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -25465,11 +25467,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -25515,7 +25517,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -25559,7 +25561,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -25753,8 +25755,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -25768,11 +25770,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -25846,7 +25848,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -25885,7 +25887,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -25951,7 +25953,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -26003,8 +26005,8 @@ local.get $0 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -26018,11 +26020,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -26117,11 +26119,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -26235,11 +26237,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -26278,11 +26280,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -26335,11 +26337,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -26388,11 +26390,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -26445,7 +26447,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -26482,7 +26484,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -26637,8 +26639,8 @@ local.get $4 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -26667,7 +26669,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -26744,7 +26746,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner00 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner00 global.get $~lib/memory/__stack_pointer @@ -26777,7 +26779,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner00 global.get $~lib/memory/__stack_pointer @@ -26920,7 +26922,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -27087,7 +27089,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -27165,8 +27167,8 @@ local.get $2 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -27186,7 +27188,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27282,7 +27284,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27368,7 +27370,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27432,8 +27434,8 @@ local.get $0 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -27449,7 +27451,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27480,7 +27482,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27587,8 +27589,8 @@ local.get $0 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -27602,11 +27604,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -27716,11 +27718,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -27797,11 +27799,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -27912,11 +27914,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -27963,7 +27965,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -27993,7 +27995,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -28087,8 +28089,8 @@ local.get $0 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -28101,11 +28103,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -28215,7 +28217,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -28311,7 +28313,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -28421,7 +28423,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -28641,8 +28643,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -28656,7 +28658,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -28788,7 +28790,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -28857,8 +28859,8 @@ local.get $3 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -28871,11 +28873,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -28944,11 +28946,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -28981,11 +28983,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -29049,7 +29051,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -29070,7 +29072,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -29097,7 +29099,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -29291,7 +29293,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -29338,7 +29340,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -29410,8 +29412,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -29426,11 +29428,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -29591,11 +29593,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -29665,11 +29667,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -29876,7 +29878,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -29952,7 +29954,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner00 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner00 global.get $~lib/memory/__stack_pointer @@ -29989,7 +29991,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner00 global.get $~lib/memory/__stack_pointer @@ -30099,7 +30101,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -30249,8 +30251,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -30263,11 +30265,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -30329,7 +30331,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -30341,7 +30343,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -30409,8 +30411,8 @@ local.get $4 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -30431,7 +30433,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner6 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner6 global.get $~lib/memory/__stack_pointer @@ -30468,6 +30470,12 @@ local.get $0 i32.const -1 i32.store offset=28 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store + local.get $0 + i32.const 0 + i32.store offset=24 end global.get $~lib/memory/__stack_pointer local.get $0 @@ -30509,12 +30517,6 @@ local.get $0 i32.store local.get $0 - i32.const 0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 i32.load offset=16 local.set $1 global.get $~lib/memory/__stack_pointer @@ -30805,7 +30807,7 @@ block $__inlined_func$assembly/interpreter/dJump$24 block $folding-inner11 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner6 global.get $~lib/memory/__stack_pointer @@ -30820,7 +30822,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner6 global.get $~lib/memory/__stack_pointer @@ -31169,7 +31171,7 @@ end i32.const 19728 i32.const 19776 - i32.const 173 + i32.const 171 i32.const 9 call $~lib/builtins/abort unreachable @@ -31233,8 +31235,8 @@ i32.const 0 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31248,11 +31250,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31309,11 +31311,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31394,11 +31396,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31455,11 +31457,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31516,11 +31518,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31579,11 +31581,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31648,11 +31650,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31714,11 +31716,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31775,11 +31777,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31844,11 +31846,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -31916,11 +31918,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -32056,7 +32058,7 @@ block $folding-inner1 block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -32097,7 +32099,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -32114,7 +32116,7 @@ i32.load offset=8 local.tee $1 i32.store - block $__inlined_func$assembly/memory/Memory#pageDump$2505 + block $__inlined_func$assembly/memory/Memory#pageDump$2506 local.get $1 local.get $0 call $"~lib/map/Map#has" @@ -32126,7 +32128,7 @@ global.set $~lib/memory/__stack_pointer i32.const 0 local.set $0 - br $__inlined_func$assembly/memory/Memory#pageDump$2505 + br $__inlined_func$assembly/memory/Memory#pageDump$2506 end global.get $~lib/memory/__stack_pointer local.get $3 @@ -32168,8 +32170,8 @@ local.get $0 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -32203,7 +32205,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -32254,7 +32256,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -32408,8 +32410,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -32425,7 +32427,7 @@ block $folding-inner1 block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -32531,7 +32533,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -32638,8 +32640,8 @@ call $~lib/builtins/abort unreachable end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -32677,7 +32679,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -32701,7 +32703,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -32874,7 +32876,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -32980,8 +32982,8 @@ local.get $5 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -33000,7 +33002,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -33076,7 +33078,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -33103,7 +33105,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -33267,8 +33269,8 @@ local.get $4 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -33286,7 +33288,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -33315,7 +33317,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -33334,7 +33336,7 @@ global.get $~lib/memory/__stack_pointer i32.const 16080 i32.store - block $__inlined_func$~lib/string/String#padStart$2543 + block $__inlined_func$~lib/string/String#padStart$2544 i32.const 16076 i32.load i32.const -2 @@ -33350,7 +33352,7 @@ i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#padStart$2543 + br $__inlined_func$~lib/string/String#padStart$2544 end global.get $~lib/memory/__stack_pointer i32.const 4 @@ -33431,8 +33433,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -33451,7 +33453,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -33556,7 +33558,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -33674,8 +33676,8 @@ local.get $0 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -33694,7 +33696,7 @@ block $folding-inner1 block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -33818,7 +33820,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -33854,7 +33856,7 @@ i32.const 1 i32.shl local.set $3 - block $__inlined_func$~lib/string/String#substring$2544 + block $__inlined_func$~lib/string/String#substring$2545 local.get $2 i32.const 0 local.get $2 @@ -33875,7 +33877,7 @@ global.set $~lib/memory/__stack_pointer i32.const 15504 local.set $0 - br $__inlined_func$~lib/string/String#substring$2544 + br $__inlined_func$~lib/string/String#substring$2545 end local.get $3 i32.eqz @@ -33890,7 +33892,7 @@ i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#substring$2544 + br $__inlined_func$~lib/string/String#substring$2545 end global.get $~lib/memory/__stack_pointer local.get $4 @@ -33920,8 +33922,8 @@ local.get $1 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -33940,11 +33942,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -33980,11 +33982,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -34023,11 +34025,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -34119,11 +34121,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -34168,7 +34170,7 @@ block $folding-inner1 block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -34201,7 +34203,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -34564,14 +34566,14 @@ i32.const 17888 local.get $0 call $~lib/string/String#concat - i32.const 20960 + i32.const 21008 i32.const 332 i32.const 7 call $~lib/builtins/abort unreachable end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -34714,7 +34716,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -34725,7 +34727,7 @@ i32.const 0 i32.const 2 i32.const 51 - i32.const 21360 + i32.const 21408 call $~lib/rt/__newArray local.tee $3 i32.store @@ -34743,7 +34745,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -34767,7 +34769,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -35048,7 +35050,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -35145,8 +35147,8 @@ local.get $3 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -35171,7 +35173,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -35298,11 +35300,37 @@ local.get $0 i32.load offset=20 call $~lib/number/I32#toString + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=8 + i32.const 20624 + local.get $2 + call $~lib/string/String#concat + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store + local.get $2 + call $~lib/console/console.log + end + local.get $1 + if + global.get $~lib/memory/__stack_pointer + i32.const 20688 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + local.get $0 + i32.store offset=12 + local.get $0 + i32.load offset=24 + i32.const 10 + call $~lib/util/number/utoa32 local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 i32.store offset=8 - i32.const 20624 + i32.const 20688 local.get $1 call $~lib/string/String#concat local.set $1 @@ -35317,7 +35345,7 @@ local.get $1 if global.get $~lib/memory/__stack_pointer - i32.const 20688 + i32.const 20736 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 @@ -35330,7 +35358,7 @@ global.get $~lib/memory/__stack_pointer local.get $2 i32.store offset=8 - i32.const 20688 + i32.const 20736 local.get $2 call $~lib/string/String#concat local.set $2 @@ -35343,7 +35371,7 @@ local.get $1 if global.get $~lib/memory/__stack_pointer - i32.const 20720 + i32.const 20768 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 @@ -35360,7 +35388,7 @@ global.get $~lib/memory/__stack_pointer local.get $2 i32.store offset=8 - i32.const 20720 + i32.const 20768 local.get $2 call $~lib/string/String#concat local.set $2 @@ -35373,7 +35401,7 @@ local.get $1 if global.get $~lib/memory/__stack_pointer - i32.const 20752 + i32.const 20800 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $0 @@ -35385,7 +35413,7 @@ global.get $~lib/memory/__stack_pointer local.get $2 i32.store offset=8 - i32.const 20752 + i32.const 20800 local.get $2 call $~lib/string/String#concat local.set $2 @@ -35441,10 +35469,10 @@ local.tee $2 i32.store offset=24 global.get $~lib/memory/__stack_pointer - i32.const 20800 + i32.const 20848 i32.store offset=32 local.get $2 - i32.const 20800 + i32.const 20848 call $~lib/staticarray/StaticArray#map<~lib/string/String> local.set $2 global.get $~lib/memory/__stack_pointer @@ -35579,38 +35607,38 @@ local.tee $2 i32.store offset=48 global.get $~lib/memory/__stack_pointer - i32.const 20912 + i32.const 20960 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $5 i32.store offset=8 - i32.const 20916 + i32.const 20964 local.get $5 i32.store - i32.const 20912 + i32.const 20960 local.get $5 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 20912 + i32.const 20960 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $2 i32.store offset=8 - i32.const 20924 + i32.const 20972 local.get $2 i32.store - i32.const 20912 + i32.const 20960 local.get $2 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 20912 + i32.const 20960 i32.store offset=4 global.get $~lib/memory/__stack_pointer i32.const 15504 i32.store offset=8 - i32.const 20912 + i32.const 20960 call $~lib/staticarray/StaticArray<~lib/string/String>#join local.set $2 global.get $~lib/memory/__stack_pointer @@ -35804,168 +35832,168 @@ local.tee $8 i32.store offset=100 global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $2 i32.store offset=8 - i32.const 21172 + i32.const 21220 local.get $2 i32.store - i32.const 21168 + i32.const 21216 local.get $2 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $3 i32.store offset=8 - i32.const 21180 + i32.const 21228 local.get $3 i32.store - i32.const 21168 + i32.const 21216 local.get $3 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $4 i32.store offset=8 - i32.const 21188 + i32.const 21236 local.get $4 i32.store - i32.const 21168 + i32.const 21216 local.get $4 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $5 i32.store offset=8 - i32.const 21196 + i32.const 21244 local.get $5 i32.store - i32.const 21168 + i32.const 21216 local.get $5 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $6 i32.store offset=8 - i32.const 21204 + i32.const 21252 local.get $6 i32.store - i32.const 21168 + i32.const 21216 local.get $6 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $9 i32.store offset=8 - i32.const 21212 + i32.const 21260 local.get $9 i32.store - i32.const 21168 + i32.const 21216 local.get $9 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $10 i32.store offset=8 - i32.const 21220 + i32.const 21268 local.get $10 i32.store - i32.const 21168 + i32.const 21216 local.get $10 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $7 i32.store offset=8 - i32.const 21228 + i32.const 21276 local.get $7 i32.store - i32.const 21168 + i32.const 21216 local.get $7 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $11 i32.store offset=8 - i32.const 21236 + i32.const 21284 local.get $11 i32.store - i32.const 21168 + i32.const 21216 local.get $11 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $12 i32.store offset=8 - i32.const 21244 + i32.const 21292 local.get $12 i32.store - i32.const 21168 + i32.const 21216 local.get $12 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $13 i32.store offset=8 - i32.const 21252 + i32.const 21300 local.get $13 i32.store - i32.const 21168 + i32.const 21216 local.get $13 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer local.get $8 i32.store offset=8 - i32.const 21260 + i32.const 21308 local.get $8 i32.store - i32.const 21168 + i32.const 21216 local.get $8 i32.const 1 call $~lib/rt/itcms/__link global.get $~lib/memory/__stack_pointer - i32.const 21168 + i32.const 21216 i32.store offset=4 global.get $~lib/memory/__stack_pointer i32.const 15504 i32.store offset=8 - i32.const 21168 + i32.const 21216 call $~lib/staticarray/StaticArray<~lib/string/String>#join local.set $2 global.get $~lib/memory/__stack_pointer @@ -35990,7 +36018,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -36025,7 +36053,7 @@ i32.const 0 i32.const 3 i32.const 56 - i32.const 21296 + i32.const 21344 call $~lib/rt/__newArray local.set $3 global.get $~lib/memory/__stack_pointer @@ -36050,7 +36078,7 @@ i32.const 0 i32.const 2 i32.const 51 - i32.const 21328 + i32.const 21376 call $~lib/rt/__newArray local.set $3 global.get $~lib/memory/__stack_pointer @@ -36109,7 +36137,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -36123,7 +36151,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -36245,24 +36273,14 @@ i32.load offset=24 i32.store offset=24 global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/memory/Memory#free - global.get $~lib/memory/__stack_pointer i32.const 108 i32.add global.set $~lib/memory/__stack_pointer local.get $2 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -36279,7 +36297,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -36316,7 +36334,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -36408,7 +36426,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -36493,8 +36511,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -36506,11 +36524,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -36543,11 +36561,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -36604,11 +36622,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -36646,11 +36664,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -36693,11 +36711,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -36863,7 +36881,7 @@ end else global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2337 (result i32) + block $__inlined_func$~lib/util/number/ulog_base$2338 (result i32) local.get $0 i64.extend_i32_u local.set $4 @@ -36884,7 +36902,7 @@ i32.div_u i32.const 1 i32.add - br $__inlined_func$~lib/util/number/ulog_base$2337 + br $__inlined_func$~lib/util/number/ulog_base$2338 end local.get $1 i64.extend_i32_s @@ -36964,11 +36982,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -37202,7 +37220,7 @@ end else global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2342 (result i32) + block $__inlined_func$~lib/util/number/ulog_base$2343 (result i32) local.get $0 local.set $2 local.get $1 @@ -37222,7 +37240,7 @@ i32.div_u i32.const 1 i32.add - br $__inlined_func$~lib/util/number/ulog_base$2342 + br $__inlined_func$~lib/util/number/ulog_base$2343 end local.get $1 i64.extend_i32_s @@ -37296,11 +37314,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -37344,11 +37362,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -37533,11 +37551,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -37566,7 +37584,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -37577,7 +37595,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -37750,8 +37768,8 @@ local.get $6 return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -37764,7 +37782,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -37778,7 +37796,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -37808,7 +37826,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -37954,8 +37972,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -37970,7 +37988,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner1 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -37984,7 +38002,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -38014,7 +38032,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -38086,7 +38104,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner1 global.get $~lib/memory/__stack_pointer @@ -38181,8 +38199,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -38195,7 +38213,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -38215,7 +38233,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -38266,8 +38284,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -38282,7 +38300,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -38293,7 +38311,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -38344,8 +38362,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -38362,7 +38380,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -38373,7 +38391,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -38454,8 +38472,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -38467,11 +38485,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -38495,11 +38513,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -38523,11 +38541,11 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s if - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -38568,7 +38586,7 @@ global.set $~lib/memory/__stack_pointer block $folding-inner0 global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -38579,7 +38597,7 @@ i32.sub global.set $~lib/memory/__stack_pointer global.get $~lib/memory/__stack_pointer - i32.const 21764 + i32.const 21812 i32.lt_s br_if $folding-inner0 global.get $~lib/memory/__stack_pointer @@ -38629,8 +38647,8 @@ global.set $~lib/memory/__stack_pointer return end - i32.const 54560 i32.const 54608 + i32.const 54656 i32.const 1 i32.const 1 call $~lib/builtins/abort From 3a2bdd5c263094410a03d46b354fc5eb24229412 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Tue, 14 Oct 2025 21:29:32 +0200 Subject: [PATCH 09/21] return exit code -1 as default --- assembly/api-debugger.ts | 6 +- assembly/interpreter.ts | 4 +- build/debug.d.ts | 2 +- build/debug.js | 4 - build/debug.wasm | Bin 199232 -> 199232 bytes build/debug.wasm.map | 2 +- build/debug.wat | 8 +- build/release.d.ts | 2 +- build/release.js | 4 - build/release.wasm | Bin 97855 -> 97855 bytes build/release.wasm.map | 2 +- build/release.wat | 8 +- build/test.wasm | Bin 189597 -> 189870 bytes build/test.wasm.map | 2 +- build/test.wat | 1587 ++++++++++++++++++++------------------ 15 files changed, 842 insertions(+), 789 deletions(-) diff --git a/assembly/api-debugger.ts b/assembly/api-debugger.ts index 788245a..dc2d153 100644 --- a/assembly/api-debugger.ts +++ b/assembly/api-debugger.ts @@ -111,12 +111,12 @@ export function getStatus(): u8 { return int.status; } -export function getExitArg(): u32 { +export function getExitArg(): i32 { if (interpreter === null) { - return 0; + return -1; } const int = interpreter; - return int.exitCode || 0; + return int.exitCode || -1; } export function getGasLeft(): i64 { diff --git a/assembly/interpreter.ts b/assembly/interpreter.ts index ad10af0..c92e839 100644 --- a/assembly/interpreter.ts +++ b/assembly/interpreter.ts @@ -36,7 +36,7 @@ export class Interpreter { this.gas = gasCounter(0); this.pc = 0; this.status = Status.OK; - this.exitCode = 0; + this.exitCode = -1; this.nextPc = 0; this.useSbrkGas = false; } @@ -50,7 +50,7 @@ export class Interpreter { // executing right away. this.pc = this.nextPc; this.nextPc = -1; - this.exitCode = 0; + this.exitCode = -1; } if (this.status !== Status.OK) { diff --git a/build/debug.d.ts b/build/debug.d.ts index 30d217a..bfa811d 100644 --- a/build/debug.d.ts +++ b/build/debug.d.ts @@ -67,7 +67,7 @@ export declare function setNextProgramCounter(pc: number): void; export declare function getStatus(): number; /** * assembly/api-debugger/getExitArg - * @returns `u32` + * @returns `i32` */ export declare function getExitArg(): number; /** diff --git a/build/debug.js b/build/debug.js index 1e7cdd6..bc5137a 100644 --- a/build/debug.js +++ b/build/debug.js @@ -87,10 +87,6 @@ async function instantiate(module, imports = {}) { // assembly/api-debugger/getProgramCounter() => u32 return exports.getProgramCounter() >>> 0; }, - getExitArg() { - // assembly/api-debugger/getExitArg() => u32 - return exports.getExitArg() >>> 0; - }, setGasLeft(gas) { // assembly/api-debugger/setGasLeft(i64) => void gas = gas || 0n; diff --git a/build/debug.wasm b/build/debug.wasm index c109be430ebcc54bca8cdb22c3fcd34740600bd7..07934d4717b52f6df52d67d21d10e5e22cab607a 100644 GIT binary patch delta 63 zcmX>wh3CK&o`x-q(#nkW(`}U)4YvCzGcJ~5tl$2@mNAW+qh66&`3<8Z&-C}6jB3+c TfCOWG`)W_d?W;YRrXBzQnB^55 delta 61 zcmX>wh3CK&o`x-q(#q3qlo$=S`zSLmmSSYs{=t?pjhll(ky-f-qa)As_nwSu(_4T9 RBSZUYPsZ)5J(;E+002+O6CVHo diff --git a/build/debug.wasm.map b/build/debug.wasm.map index 0c0d1f5..06da30a 100644 --- a/build/debug.wasm.map +++ b/build/debug.wasm.map @@ -1 +1 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n this.exitCode = 0;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n if (logs) console.log(`Exit code: ${int.exitCode}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = -1;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n this.exitCode = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): i32 {\n if (interpreter === null) {\n return -1;\n }\n const int = interpreter;\n return int.exitCode || -1;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n if (logs) console.log(`Exit code: ${int.exitCode}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/debug.wat b/build/debug.wat index 6287876..35d2a41 100644 --- a/build/debug.wat +++ b/build/debug.wat @@ -34194,7 +34194,7 @@ local.get $4 i32.store offset=4 local.get $4 - i32.const 0 + i32.const -1 call $assembly/interpreter/Interpreter#set:exitCode local.get $this local.set $4 @@ -37320,7 +37320,7 @@ local.get $14 i32.store local.get $14 - i32.const 0 + i32.const -1 call $assembly/interpreter/Interpreter#set:exitCode end local.get $this @@ -38634,7 +38634,7 @@ i32.const 0 i32.eq if - i32.const 0 + i32.const -1 local.set $3 global.get $~lib/memory/__stack_pointer i32.const 12 @@ -38672,7 +38672,7 @@ if (result i32) local.get $2 else - i32.const 0 + i32.const -1 end local.set $3 global.get $~lib/memory/__stack_pointer diff --git a/build/release.d.ts b/build/release.d.ts index 30d217a..bfa811d 100644 --- a/build/release.d.ts +++ b/build/release.d.ts @@ -67,7 +67,7 @@ export declare function setNextProgramCounter(pc: number): void; export declare function getStatus(): number; /** * assembly/api-debugger/getExitArg - * @returns `u32` + * @returns `i32` */ export declare function getExitArg(): number; /** diff --git a/build/release.js b/build/release.js index 2061561..7fd5896 100644 --- a/build/release.js +++ b/build/release.js @@ -87,10 +87,6 @@ async function instantiate(module, imports = {}) { // assembly/api-debugger/getProgramCounter() => u32 return exports.getProgramCounter() >>> 0; }, - getExitArg() { - // assembly/api-debugger/getExitArg() => u32 - return exports.getExitArg() >>> 0; - }, setGasLeft(gas) { // assembly/api-debugger/setGasLeft(i64) => void gas = gas || 0n; diff --git a/build/release.wasm b/build/release.wasm index 439ab36fc7ff05b498050bc555ce3067b7178c35..78b9842a96fab8f4348e56df8c35decf452c7135 100644 GIT binary patch delta 40 vcmdo0hjsrS)(v}~GuCh3_k02`kn;bU!pT@a+5W%uM20KY1Yc{l9>E0M2I>X#fBK diff --git a/build/release.wasm.map b/build/release.wasm.map index a17f808..ed93bf6 100644 --- a/build/release.wasm.map +++ b/build/release.wasm.map @@ -1 +1 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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V,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDzCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAG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,E,KAAA,G,IAAW,E,KLkBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTuIO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDS/IM,E,KAAc,E,YAAd,G,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,G,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/EgB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,EACE,E,KAAc,E,KAAA,G,IAAyB,EbyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GazDb,Gf+BK,E,6DexBH,E,KAAc,E,KbuDiB,E,EavDjB,G,EbuDuC,CAAlD,EAAK,EAAL,EavDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EatDM,G,EbsDgB,CAAlD,EAAK,EAAL,EatDoB,EAAzB,GfuBK,E,6DehBH,E,KAAc,E,Kb+CiB,E,Ea/CjB,G,Eb+CuC,CAAlD,EAAK,EAAL,Ea/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea9CM,G,Eb8CgB,CAAlD,EAAK,EAAL,Ea9CoB,EAAzB,GfeK,E,6DgB9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,Kd6EL,E,Ec7EK,G,Ed6EiB,CAAlD,EAAK,EAAL,Ec7EwB,E,IAAiC,EdwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,Ec7EwB,E,EdwEhB,GcvBN,CAjDT,EhB8CO,E,6DgBxCP,E,YAAS,G,IAAoC,E,KdkE9B,G,IclEuC,E,KAAS,E,KduE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EcvE4B,G,EduEN,CAAlD,EAAK,EAAL,EcvE+C,EA2C7C,CA3CT,EhBwCO,E,6DgBlCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdiE1B,E,EcjE0B,G,EdiEJ,CAAlD,EAAK,EAAL,E,EcjEyC,C,IAA4B,EAyCtD,G,EdwBa,E,EAAsB,CAAlD,EAAK,EAAL,EcjEyC,E,EAyC1B,GAAb,CdmBF,Cc5DP,EhBkCO,E,6DgB5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,Kd2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EcxBY,E,EdwBgB,E,Ec3DuC,G,Ed2DjB,CAAlD,EAAK,EAAL,E,Ec3DsD,CAmCpD,CdmBF,CctDP,EhB4BO,E,6DgBtBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdqDL,E,EcrDK,G,EdqDiB,CAAlD,EAAK,EAAL,EcrDwB,E,IAAmB,E,KAAS,E,KdqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EcrDwB,E,EdqDI,E,EcrDwB,G,EdqDF,CAAlD,EAAK,EAAL,EcrD2C,EAiCzC,CAjCT,EhBsBO,E,6DgBhBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,Kd+C1B,E,Ec/C0B,G,Ed+CJ,CAAlD,EAAK,EAAL,E,Ec/CyC,C,IAA4B,E,KAAS,E,Kd+ClD,E,EAAsB,CAAlD,EAAK,EAAL,Ec/CyC,E,Ed+Cb,E,Ec/CkD,G,Ed+C5B,CAAlD,EAAK,EAAL,E,Ec/CiE,CA+B/D,CdWF,Cc1CP,EhBgBO,E,6DgBVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdyCL,E,EczCK,G,EdyCiB,CAAlD,EAAK,EAAL,EczCwB,E,IAAmB,E,KAAS,E,KdyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EczCwB,E,EdyCI,E,EczCwB,G,EdyCF,CAAlD,EAAK,EAAL,EczC2C,EAazC,CAbT,EhBUO,E,6DgBJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdmC1B,E,EcnC0B,G,EdmCJ,CAAlD,EAAK,EAAL,E,EcnCyC,C,IAA4B,E,KAAS,E,KdmClD,E,EAAsB,CAAlD,EAAK,EAAL,EcnCyC,E,EdmCb,E,EcnCkD,G,EdmC5B,CAAlD,EAAK,EAAL,E,EcnCiE,CAW/D,CdmBF,Cc9BP,EhBIO,E,sDiB9CM,E,Yf6EsB,E,Ee7ER,G,Ef6E8B,CAAlD,EAAK,EAAL,Ee7EM,E,EAA2C,EfwEzC,G,EAAA,GexEF,CAAb,E,EACA,E,KAAc,E,Kf4EqB,E,Ee5ErB,G,Ef4E2C,CAAlD,EAAK,EAAL,Ee5EkB,GAAzB,EjB6CO,E,sDiBvCU,E,YfsEkB,E,EetEJ,G,EfsE0B,CAAlD,EAAK,EAAL,EetEM,E,EAA4C,EfiE1C,G,EAAA,GejEF,CAAb,E,EACA,E,KAAc,E,KfqEqB,E,EerErB,G,EfqE2C,CAAlD,EAAK,EAAL,EerEkB,GAAzB,EjBsCO,E,sDiBhCM,E,Yf+DsB,E,Ee/DR,G,Ef+D8B,CAAlD,EAAK,EAAL,Ee/DM,E,EAA2C,Ef0DzC,G,EAAA,Ge1DF,CAAb,E,EACA,E,KAAc,E,Kf8DqB,E,Ee9DrB,G,Ef8D2C,CAAlD,EAAK,EAAL,Ee9DkB,GAAzB,EjB+BO,E,sDiBzBU,E,YfwDkB,E,EexDJ,G,EfwD0B,CAAlD,EAAK,EAAL,EexDM,E,EAA4C,EfmD1C,G,EAAA,GenDF,CAAb,E,EACA,E,KAAc,E,KfuDqB,E,EevDrB,G,EfuD2C,CAAlD,EAAK,EAAL,EevDkB,GAAzB,EjBwBO,E,6DiBlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KfiDJ,E,EejDI,G,EfiDkB,CAAlD,EAAK,EAAL,EejDkB,E,IAAyB,E,KAAc,E,KfiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EejD6B,G,EfiDP,CAAlD,EAAK,EAAL,EejD2C,EAAzB,IAAzB,EjBkBO,E,6DiBZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kf2CR,E,Ee3CQ,G,Ef2Cc,CAAlD,EAAK,EAAL,Ee3CkB,E,IAAkC,E,KAAc,E,Kf2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ee3CsC,G,Ef2ChB,CAAlD,EAAK,EAAL,Ee3CgD,EAA9B,IAAzB,EjBYO,E,wDkB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhByEG,E,EgBzEH,G,EhByEyB,CAAlD,EAAK,EAAL,E,EgBzEO,CAAd,E,EACA,E,KAAc,E,KhBwEqB,E,EgBxErB,G,EhBwE2C,CAAlD,EAAK,EAAL,EgBxEgC,EAAS,EAAT,ChBmEhC,CgBnEP,ElByCO,E,wDkBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBiEG,E,EgBjEH,G,EhBiEyB,CAAlD,EAAK,EAAL,E,EgBjEO,CAAd,E,EACA,E,KAAc,E,KhBgEqB,E,EgBhErB,G,EhBgE2C,CAAlD,EAAK,EAAL,EgBhEgC,EAAU,EAAV,ChB2DhC,CgB3DP,ElBiCO,E,sDkB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KhByDX,E,EgBzDW,G,EhByDW,CAAlD,EAAK,EAAL,E,EgBzDqB,CAA5B,E,EACA,E,KAAc,E,KhBwDqB,E,EgBxDrB,G,EhBwD2C,CAAlD,EAAK,EAAL,EgBxDkB,E,EAAS,CAAT,CAAzB,ElByBO,E,sDkBnBW,E,KAAc,E,KhBkDG,E,EgBlDH,G,EhBkDyB,CAAlD,EAAK,EAAL,EgBlDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhBiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgBjD0C,EAAV,ChB4ChC,CgB5CP,ElBkBO,E,sDkBZW,E,KAAc,E,KhB2CG,E,EgB3CH,G,EhB2CyB,CAAlD,EAAK,EAAL,EgB3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhB0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgB1C2C,EAAX,ChBqChC,CgBrCP,ElBWO,E,sDkBLW,E,YhBoCiB,E,EgBpCH,G,EhBoCyB,CAAlD,EAAK,EAAL,EgBpCW,E,GAAJ,CAAd,E,EAC0B,E,KhB8BX,GgB9Bf,E,EACA,E,KAAc,E,KhBkCqB,E,EgBlCrB,G,EhBkC2C,CAAlD,EAAK,EAAL,EgBlCoC,E,EAAO,C,CAAX,CAAvC,ElBGO,E,6DkBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhB2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgB3BI,G,EhB2BkB,CAAlD,EAAK,EAAL,EgB3BkB,E,EAA0B,CAA1B,CAAzB,ElBJO,E,6DkBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBpBI,G,EhBoBkB,CAAlD,EAAK,EAAL,EgBpBkB,E,EAA2B,CAA3B,CAAzB,ElBXO,E,sDkBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBaG,E,EgBbH,G,EhBayB,CAAlD,EAAK,EAAL,EgBbO,EAAd,E,EACA,E,KAAc,E,KhBYqB,E,EgBZrB,G,EhBY2C,CAAlD,EAAK,EAAL,EgBZkB,E,EAAS,CAAT,CAAzB,ElBnBO,E,sDkByBW,E,KAAc,E,KhBMG,E,EgBNH,G,EhBMyB,CAAlD,EAAK,EAAL,EgBNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBAmC,CAAzB,CAAzB,ElB1BO,E,sDkBgCW,E,KAAc,E,KhBDG,E,EgBCH,G,EhBDyB,CAAlD,EAAK,EAAL,EgBCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBOoC,CAA1B,CAAzB,ElBjCO,E,sDkBuCW,E,YhBRiB,E,EgBQH,G,EhBRyB,CAAlD,EAAK,EAAL,EgBQW,E,GAAJ,CAAd,E,EAC4B,E,KhBdb,GgBcf,E,EACA,E,KAAc,E,KhBVqB,E,EgBUrB,G,EhBV2C,CAAlD,EAAK,EAAL,EgBUoC,E,EAAS,C,CAAb,CAAvC,ElBzCO,E,wDkB+CW,E,KAAc,E,KhBhBG,E,EgBgBH,G,EhBhByB,CAAlD,EAAK,EAAL,EgBgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBjBG,E,EgBiBH,G,EhBjByB,CAAlD,EAAK,EAAL,E,EgBiBO,CAAd,E,EACA,E,KAAc,E,KhBlBqB,E,EgBkBrB,G,EhBlB2C,CAAlD,EAAK,EAAL,EgBkBgC,EAAS,EAAT,ChBvBhC,CgBuBP,ElBjDO,E,wDkBuDW,E,KAAc,E,KhBxBG,E,EgBwBH,G,EhBxByB,CAAlD,EAAK,EAAL,EgBwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBzBG,E,EgByBH,G,EhBzByB,CAAlD,EAAK,EAAL,E,EgByBO,CAAd,E,EACA,E,KAAc,E,KhB1BqB,E,EgB0BrB,G,EhB1B2C,CAAlD,EAAK,EAAL,EgB0BgC,EAAU,EAAV,ChB/BhC,CgB+BP,ElBzDO,E,sDkB+DW,E,KAAc,E,KhBhCG,E,EgBgCH,G,EhBhCyB,CAAlD,EAAK,EAAL,EgBgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KhBjCd,E,EgBiCc,G,EhBjCQ,CAAlD,EAAK,EAAL,E,EgBiCwB,CAA/B,E,EACA,E,KAAc,E,KhBlCqB,E,EgBkCrB,G,EhBlC2C,CAAlD,EAAK,EAAL,EgBkCoC,E,EAAY,C,CAAhB,CAAvC,ElBjEO,E,6DkBuEW,E,KAAc,E,KhBxCG,E,EgBwCH,G,EhBxCyB,CAAlD,EAAK,EAAL,EgBwCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBzCJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgByCI,G,EhBzCkB,CAAlD,EAAK,EAAL,EgByCkB,E,EAA0B,CAA1B,CAAzB,ElBxEO,E,6DkB8EW,E,KAAc,E,KhB/CG,E,EgB+CH,G,EhB/CyB,CAAlD,EAAK,EAAL,EgB+CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBhDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBgDI,G,EhBhDkB,CAAlD,EAAK,EAAL,EgBgDkB,E,EAA2B,CAA3B,CAAzB,ElB/EO,E,6DkBqFW,E,KAAc,E,KhBtDG,E,EgBsDH,G,EhBtDyB,CAAlD,EAAK,EAAL,EgBsDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,KhBvDR,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBuDQ,G,EhBvDc,CAAlD,EAAK,EAAL,EgBuDkB,E,EAA+B,CAA/B,CAAzB,ElBtFO,E,mDV8HkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cACnD,E,GAAiB,E,KAAjB,CAA+B,EAAzC,G,2DQ4EY,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,E,IAAf,G,EACO,E,kEqB9PO,E,QAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,2DrBgQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,EAAQ,GAAR,CAAf,G,EACI,E,iBAAA,EAAmB,EAAnB,CAAJ,E,EACE,E,iBAAU,EAAK,E,KAAS,EAAT,CAAf,I,EAEA,E,iBAAW,EAAK,E,KAAS,EAAT,CAAhB,I,EAEK,E,kEqBrQO,E,QAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DrBuQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,EAAK,EAAI,GAAJ,CAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,EAAK,EAAI,GAAJ,CAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEqBpRO,E,QAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DrBsRO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,E,EAAK,C,IAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,E,EAAK,C,IAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEqBnSO,E,QAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBkDjB,GiBlDG,G,OACD,E,KAAV,E,+DAKO,E,KAAa,E,YAAa,E,KAAc,E,WjBiDnB,E,EiBjDmB,G,EjBiDG,CAAlD,EAAK,EAAL,EiBjDiC,EAAyB,G,CAA9B,CAArB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAc,E,KAAc,E,WjB2CrB,E,EiB3CqB,G,EjB2CC,CAAlD,EAAK,EAAL,EiB3CmC,EAAyB,I,CAA/B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAY,E,KAAc,E,WjBqCnB,E,EiBrCmB,G,EjBqCG,CAAlD,EAAK,EAAL,E,EiBrC6B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAQ,E,KAAc,E,WjB+Bf,E,EiB/Be,G,EjB+BO,CAAlD,EAAK,EAAL,EiB/B6B,EAAtB,G,OACG,E,KAAV,E,6DAKa,E,YjByBe,E,EiBzBD,G,EjByBuB,CAAlD,EAAK,EAAL,EiBzBa,E,EAAuC,EjBoB5C,G,EAAA,G,CiBpBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YjBkBe,E,EiBlBD,G,EjBkBuB,CAAlD,EAAK,EAAL,EiBlBa,E,EAAuC,EjBa5C,G,EAAA,G,CiBbC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YjBWe,E,EiBXD,G,EjBWuB,CAAlD,EAAK,EAAL,EiBXa,E,EAAuC,EjBM5C,G,EAAA,G,CiBNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YjBIe,E,EiBJD,G,EjBIuB,CAAlD,EAAK,EAAL,EiBJa,E,EAAuC,EjBD5C,G,EAAA,G,CiBCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBFjB,GiBEG,G,OACD,E,KAAV,E,+DAKa,E,YjBHe,E,EiBGD,G,EjBHuB,CAAlD,EAAK,EAAL,EiBGa,E,EAAuC,EjBR5C,G,EAAA,G,CiBQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EjBJQ,E,EiBIoB,G,EjBJE,CAAlD,EAAK,EAAL,EiBIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YjBVe,E,EiBUD,G,EjBVuB,CAAlD,EAAK,EAAL,EiBUa,E,EAAuC,EjBf5C,G,EAAA,G,CiBeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EjBXO,E,EiBWsB,G,EjBXA,CAAlD,EAAK,EAAL,EiBWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBjBe,E,EiBiBD,G,EjBjBuB,CAAlD,EAAK,EAAL,EiBiBa,E,EAAuC,EjBtB5C,G,EAAA,G,CiBsBC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA3B,E,EjBlBO,E,EiBkBoB,G,EjBlBE,CAAlD,EAAK,EAAL,E,EiBkB8B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBxBe,E,EiBwBD,G,EjBxBuB,CAAlD,E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E,KAOmC,G,EANnC,EAMwC,G,EAAA,G,aAArB,G,wD2B5KI,E,KAAN,E,EAAY,EAA5B,G,KACT,GAAJ,E,OACS,EAAP,E,yEAfO,E,YACA,E,YACA,E,YACA,E,UACO,E,sCAehB,E,KAAmB,E,gCAEX,E,mBAOJ,E,KAA2B,E,OpB5MhB,G,QoBmNX,E,KAAa,E,KAAc,E,OpB9MI,E,EoB8MJ,G,EpB9M0B,CAAlD,EAAK,EAAL,EoB8MU,E,QAIb,E,KAAa,E,KAAc,E,OpBlNI,E,EoBkNJ,G,EpBlN0B,CAAlD,EAAK,EAAL,EoBkNU,E,KACb,E,KAAkB,E,KAAJ,GAAe,EAAf,C,IAAyB,EAAJ,G,EAArB,E,EAAqB,GAAtB,C,QAab,E,KAAa,E,KAAc,E,OpBhOI,E,EoBgOJ,G,EpBhO0B,CAAlD,EAAK,EAAL,EoBgOU,E,KACb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,QAab,E,KAAa,E,KAAc,E,OpB9OI,E,EoB8OJ,G,EpB9O0B,CAAlD,EAAK,EAAL,EoB8OU,E,KACb,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAA2B,E,OpBrPhB,G,KoBsPX,E,KAA2B,E,OpBtPhB,G,QoByPX,E,KAAa,E,KAAc,E,OpBpPI,E,EoBoPJ,G,EpBpP0B,CAAlD,EAAK,EAAL,EoBoPU,E,KACb,E,KAAa,E,KAAc,E,OpBrPI,E,EoBqPJ,G,EpBrP0B,CAAlD,EAAK,EAAL,EoBqPU,E,KACb,E,KAAa,E,KAAc,E,OpBtPI,E,EoBsPJ,G,EpBtP0B,CAAlD,EAAK,EAAL,EoBsPU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBzMhB,G,QoB6MX,E,KAA2B,E,OpB7MhB,G,QoB2NX,E,KAAa,E,KAAc,E,OpBtNI,E,EoBsNJ,G,EpBtN0B,CAAlD,EAAK,EAAL,EoBsNU,E,KACb,E,KAA2B,E,OpB5NhB,G,QoByOX,E,KAAa,E,KAAc,E,OpBpOI,E,EoBoOJ,G,EpBpO0B,CAAlD,EAAK,EAAL,EoBoOU,E,KACb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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = 0;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n this.exitCode = 0;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.exitCode || 0;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n if (logs) console.log(`Exit code: ${int.exitCode}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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V,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDzCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAG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,E,KAAA,G,IAAW,E,KLkBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTuIO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDS/IM,E,KAAc,E,YAAd,G,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,G,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/EgB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,EACE,E,KAAc,E,KAAA,G,IAAyB,EbyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GazDb,Gf+BK,E,6DexBH,E,KAAc,E,KbuDiB,E,EavDjB,G,EbuDuC,CAAlD,EAAK,EAAL,EavDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EatDM,G,EbsDgB,CAAlD,EAAK,EAAL,EatDoB,EAAzB,GfuBK,E,6DehBH,E,KAAc,E,Kb+CiB,E,Ea/CjB,G,Eb+CuC,CAAlD,EAAK,EAAL,Ea/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea9CM,G,Eb8CgB,CAAlD,EAAK,EAAL,Ea9CoB,EAAzB,GfeK,E,6DgB9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,Kd6EL,E,Ec7EK,G,Ed6EiB,CAAlD,EAAK,EAAL,Ec7EwB,E,IAAiC,EdwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,Ec7EwB,E,EdwEhB,GcvBN,CAjDT,EhB8CO,E,6DgBxCP,E,YAAS,G,IAAoC,E,KdkE9B,G,IclEuC,E,KAAS,E,KduE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EcvE4B,G,EduEN,CAAlD,EAAK,EAAL,EcvE+C,EA2C7C,CA3CT,EhBwCO,E,6DgBlCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdiE1B,E,EcjE0B,G,EdiEJ,CAAlD,EAAK,EAAL,E,EcjEyC,C,IAA4B,EAyCtD,G,EdwBa,E,EAAsB,CAAlD,EAAK,EAAL,EcjEyC,E,EAyC1B,GAAb,CdmBF,Cc5DP,EhBkCO,E,6DgB5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,Kd2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EcxBY,E,EdwBgB,E,Ec3DuC,G,Ed2DjB,CAAlD,EAAK,EAAL,E,Ec3DsD,CAmCpD,CdmBF,CctDP,EhB4BO,E,6DgBtBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdqDL,E,EcrDK,G,EdqDiB,CAAlD,EAAK,EAAL,EcrDwB,E,IAAmB,E,KAAS,E,KdqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EcrDwB,E,EdqDI,E,EcrDwB,G,EdqDF,CAAlD,EAAK,EAAL,EcrD2C,EAiCzC,CAjCT,EhBsBO,E,6DgBhBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,Kd+C1B,E,Ec/C0B,G,Ed+CJ,CAAlD,EAAK,EAAL,E,Ec/CyC,C,IAA4B,E,KAAS,E,Kd+ClD,E,EAAsB,CAAlD,EAAK,EAAL,Ec/CyC,E,Ed+Cb,E,Ec/CkD,G,Ed+C5B,CAAlD,EAAK,EAAL,E,Ec/CiE,CA+B/D,CdWF,Cc1CP,EhBgBO,E,6DgBVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdyCL,E,EczCK,G,EdyCiB,CAAlD,EAAK,EAAL,EczCwB,E,IAAmB,E,KAAS,E,KdyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EczCwB,E,EdyCI,E,EczCwB,G,EdyCF,CAAlD,EAAK,EAAL,EczC2C,EAazC,CAbT,EhBUO,E,6DgBJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdmC1B,E,EcnC0B,G,EdmCJ,CAAlD,EAAK,EAAL,E,EcnCyC,C,IAA4B,E,KAAS,E,KdmClD,E,EAAsB,CAAlD,EAAK,EAAL,EcnCyC,E,EdmCb,E,EcnCkD,G,EdmC5B,CAAlD,EAAK,EAAL,E,EcnCiE,CAW/D,CdmBF,Cc9BP,EhBIO,E,sDiB9CM,E,Yf6EsB,E,Ee7ER,G,Ef6E8B,CAAlD,EAAK,EAAL,Ee7EM,E,EAA2C,EfwEzC,G,EAAA,GexEF,CAAb,E,EACA,E,KAAc,E,Kf4EqB,E,Ee5ErB,G,Ef4E2C,CAAlD,EAAK,EAAL,Ee5EkB,GAAzB,EjB6CO,E,sDiBvCU,E,YfsEkB,E,EetEJ,G,EfsE0B,CAAlD,EAAK,EAAL,EetEM,E,EAA4C,EfiE1C,G,EAAA,GejEF,CAAb,E,EACA,E,KAAc,E,KfqEqB,E,EerErB,G,EfqE2C,CAAlD,EAAK,EAAL,EerEkB,GAAzB,EjBsCO,E,sDiBhCM,E,Yf+DsB,E,Ee/DR,G,Ef+D8B,CAAlD,EAAK,EAAL,Ee/DM,E,EAA2C,Ef0DzC,G,EAAA,Ge1DF,CAAb,E,EACA,E,KAAc,E,Kf8DqB,E,Ee9DrB,G,Ef8D2C,CAAlD,EAAK,EAAL,Ee9DkB,GAAzB,EjB+BO,E,sDiBzBU,E,YfwDkB,E,EexDJ,G,EfwD0B,CAAlD,EAAK,EAAL,EexDM,E,EAA4C,EfmD1C,G,EAAA,GenDF,CAAb,E,EACA,E,KAAc,E,KfuDqB,E,EevDrB,G,EfuD2C,CAAlD,EAAK,EAAL,EevDkB,GAAzB,EjBwBO,E,6DiBlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KfiDJ,E,EejDI,G,EfiDkB,CAAlD,EAAK,EAAL,EejDkB,E,IAAyB,E,KAAc,E,KfiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EejD6B,G,EfiDP,CAAlD,EAAK,EAAL,EejD2C,EAAzB,IAAzB,EjBkBO,E,6DiBZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kf2CR,E,Ee3CQ,G,Ef2Cc,CAAlD,EAAK,EAAL,Ee3CkB,E,IAAkC,E,KAAc,E,Kf2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ee3CsC,G,Ef2ChB,CAAlD,EAAK,EAAL,Ee3CgD,EAA9B,IAAzB,EjBYO,E,wDkB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhByEG,E,EgBzEH,G,EhByEyB,CAAlD,EAAK,EAAL,E,EgBzEO,CAAd,E,EACA,E,KAAc,E,KhBwEqB,E,EgBxErB,G,EhBwE2C,CAAlD,EAAK,EAAL,EgBxEgC,EAAS,EAAT,ChBmEhC,CgBnEP,ElByCO,E,wDkBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBiEG,E,EgBjEH,G,EhBiEyB,CAAlD,EAAK,EAAL,E,EgBjEO,CAAd,E,EACA,E,KAAc,E,KhBgEqB,E,EgBhErB,G,EhBgE2C,CAAlD,EAAK,EAAL,EgBhEgC,EAAU,EAAV,ChB2DhC,CgB3DP,ElBiCO,E,sDkB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KhByDX,E,EgBzDW,G,EhByDW,CAAlD,EAAK,EAAL,E,EgBzDqB,CAA5B,E,EACA,E,KAAc,E,KhBwDqB,E,EgBxDrB,G,EhBwD2C,CAAlD,EAAK,EAAL,EgBxDkB,E,EAAS,CAAT,CAAzB,ElByBO,E,sDkBnBW,E,KAAc,E,KhBkDG,E,EgBlDH,G,EhBkDyB,CAAlD,EAAK,EAAL,EgBlDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhBiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgBjD0C,EAAV,ChB4ChC,CgB5CP,ElBkBO,E,sDkBZW,E,KAAc,E,KhB2CG,E,EgB3CH,G,EhB2CyB,CAAlD,EAAK,EAAL,EgB3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhB0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgB1C2C,EAAX,ChBqChC,CgBrCP,ElBWO,E,sDkBLW,E,YhBoCiB,E,EgBpCH,G,EhBoCyB,CAAlD,EAAK,EAAL,EgBpCW,E,GAAJ,CAAd,E,EAC0B,E,KhB8BX,GgB9Bf,E,EACA,E,KAAc,E,KhBkCqB,E,EgBlCrB,G,EhBkC2C,CAAlD,EAAK,EAAL,EgBlCoC,E,EAAO,C,CAAX,CAAvC,ElBGO,E,6DkBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhB2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgB3BI,G,EhB2BkB,CAAlD,EAAK,EAAL,EgB3BkB,E,EAA0B,CAA1B,CAAzB,ElBJO,E,6DkBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBpBI,G,EhBoBkB,CAAlD,EAAK,EAAL,EgBpBkB,E,EAA2B,CAA3B,CAAzB,ElBXO,E,sDkBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBaG,E,EgBbH,G,EhBayB,CAAlD,EAAK,EAAL,EgBbO,EAAd,E,EACA,E,KAAc,E,KhBYqB,E,EgBZrB,G,EhBY2C,CAAlD,EAAK,EAAL,EgBZkB,E,EAAS,CAAT,CAAzB,ElBnBO,E,sDkByBW,E,KAAc,E,KhBMG,E,EgBNH,G,EhBMyB,CAAlD,EAAK,EAAL,EgBNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBAmC,CAAzB,CAAzB,ElB1BO,E,sDkBgCW,E,KAAc,E,KhBDG,E,EgBCH,G,EhBDyB,CAAlD,EAAK,EAAL,EgBCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBOoC,CAA1B,CAAzB,ElBjCO,E,sDkBuCW,E,YhBRiB,E,EgBQH,G,EhBRyB,CAAlD,EAAK,EAAL,EgBQW,E,GAAJ,CAAd,E,EAC4B,E,KhBdb,GgBcf,E,EACA,E,KAAc,E,KhBVqB,E,EgBUrB,G,EhBV2C,CAAlD,EAAK,EAAL,EgBUoC,E,EAAS,C,CAAb,CAAvC,ElBzCO,E,wDkB+CW,E,KAAc,E,KhBhBG,E,EgBgBH,G,EhBhByB,CAAlD,EAAK,EAAL,EgBgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBjBG,E,EgBiBH,G,EhBjByB,CAAlD,EAAK,EAAL,E,EgBiBO,CAAd,E,EACA,E,KAAc,E,KhBlBqB,E,EgBkBrB,G,EhBlB2C,CAAlD,EAAK,EAAL,EgBkBgC,EAAS,EAAT,ChBvBhC,CgBuBP,ElBjDO,E,wDkBuDW,E,KAAc,E,KhBxBG,E,EgBwBH,G,EhBxByB,CAAlD,EAAK,EAAL,EgBwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBzBG,E,EgByBH,G,EhBzByB,CAAlD,EAAK,EAAL,E,EgByBO,CAAd,E,EACA,E,KAAc,E,KhB1BqB,E,EgB0BrB,G,EhB1B2C,CAAlD,EAAK,EAAL,EgB0BgC,EAAU,EAAV,ChB/BhC,CgB+BP,ElBzDO,E,sDkB+DW,E,KAAc,E,KhBhCG,E,EgBgCH,G,EhBhCyB,CAAlD,EAAK,EAAL,EgBgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KhBjCd,E,EgBiCc,G,EhBjCQ,CAAlD,EAAK,EAAL,E,EgBiCwB,CAA/B,E,EACA,E,KAAc,E,KhBlCqB,E,EgBkCrB,G,EhBlC2C,CAAlD,EAAK,EAAL,EgBkCoC,E,EAAY,C,CAAhB,CAAvC,ElBjEO,E,6DkBuEW,E,KAAc,E,KhBxCG,E,EgBwCH,G,EhBxCyB,CAAlD,EAAK,EAAL,EgBwCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBzCJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgByCI,G,EhBzCkB,CAAlD,EAAK,EAAL,EgByCkB,E,EAA0B,CAA1B,CAAzB,ElBxEO,E,6DkB8EW,E,KAAc,E,KhB/CG,E,EgB+CH,G,EhB/CyB,CAAlD,EAAK,EAAL,EgB+CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBhDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBgDI,G,EhBhDkB,CAAlD,EAAK,EAAL,EgBgDkB,E,EAA2B,CAA3B,CAAzB,ElB/EO,E,6DkBqFW,E,KAAc,E,KhBtDG,E,EgBsDH,G,EhBtDyB,CAAlD,EAAK,EAAL,EgBsDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,KhBvDR,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBuDQ,G,EhBvDc,CAAlD,EAAK,EAAL,EgBuDkB,E,EAA+B,CAA/B,CAAzB,ElBtFO,E,mDV8HkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cACnD,E,GAAiB,E,KAAjB,CAA+B,EAAzC,G,2DQ4EY,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,E,IAAf,G,EACO,E,kEqB9PO,E,QAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,2DrBgQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,EAAQ,GAAR,CAAf,G,EACI,E,iBAAA,EAAmB,EAAnB,CAAJ,E,EACE,E,iBAAU,EAAK,E,KAAS,EAAT,CAAf,I,EAEA,E,iBAAW,EAAK,E,KAAS,EAAT,CAAhB,I,EAEK,E,kEqBrQO,E,QAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DrBuQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,EAAK,EAAI,GAAJ,CAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,EAAK,EAAI,GAAJ,CAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEqBpRO,E,QAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DrBsRO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,E,EAAK,C,IAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,E,EAAK,C,IAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEqBnSO,E,QAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBkDjB,GiBlDG,G,OACD,E,KAAV,E,+DAKO,E,KAAa,E,YAAa,E,KAAc,E,WjBiDnB,E,EiBjDmB,G,EjBiDG,CAAlD,EAAK,EAAL,EiBjDiC,EAAyB,G,CAA9B,CAArB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAc,E,KAAc,E,WjB2CrB,E,EiB3CqB,G,EjB2CC,CAAlD,EAAK,EAAL,EiB3CmC,EAAyB,I,CAA/B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAY,E,KAAc,E,WjBqCnB,E,EiBrCmB,G,EjBqCG,CAAlD,EAAK,EAAL,E,EiBrC6B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAQ,E,KAAc,E,WjB+Bf,E,EiB/Be,G,EjB+BO,CAAlD,EAAK,EAAL,EiB/B6B,EAAtB,G,OACG,E,KAAV,E,6DAKa,E,YjByBe,E,EiBzBD,G,EjByBuB,CAAlD,EAAK,EAAL,EiBzBa,E,EAAuC,EjBoB5C,G,EAAA,G,CiBpBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YjBkBe,E,EiBlBD,G,EjBkBuB,CAAlD,EAAK,EAAL,EiBlBa,E,EAAuC,EjBa5C,G,EAAA,G,CiBbC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YjBWe,E,EiBXD,G,EjBWuB,CAAlD,EAAK,EAAL,EiBXa,E,EAAuC,EjBM5C,G,EAAA,G,CiBNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YjBIe,E,EiBJD,G,EjBIuB,CAAlD,EAAK,EAAL,EiBJa,E,EAAuC,EjBD5C,G,EAAA,G,CiBCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBFjB,GiBEG,G,OACD,E,KAAV,E,+DAKa,E,YjBHe,E,EiBGD,G,EjBHuB,CAAlD,EAAK,EAAL,EiBGa,E,EAAuC,EjBR5C,G,EAAA,G,CiBQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EjBJQ,E,EiBIoB,G,EjBJE,CAAlD,EAAK,EAAL,EiBIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YjBVe,E,EiBUD,G,EjBVuB,CAAlD,EAAK,EAAL,EiBUa,E,EAAuC,EjBf5C,G,EAAA,G,CiBeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EjBXO,E,EiBWsB,G,EjBXA,CAAlD,EAAK,EAAL,EiBWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBjBe,E,EiBiBD,G,EjBjBuB,CAAlD,EAAK,EAAL,EiBiBa,E,EAAuC,EjBtB5C,G,EAAA,G,CiBsBC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA3B,E,EjBlBO,E,EiBkBoB,G,EjBlBE,CAAlD,EAAK,EAAL,E,EiBkB8B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBxBe,E,EiBwBD,G,EjBxBuB,CAAlD,E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E,KAOmC,G,EANnC,EAMwC,G,EAAA,G,aAArB,G,wD2B5KI,E,KAAN,E,EAAY,EAA5B,G,KACT,GAAJ,E,OACS,EAAP,E,yEAfO,E,YACA,E,YACA,E,YACA,E,UACO,E,sCAehB,E,KAAmB,E,gCAEX,E,mBAOJ,E,KAA2B,E,OpB5MhB,G,QoBmNX,E,KAAa,E,KAAc,E,OpB9MI,E,EoB8MJ,G,EpB9M0B,CAAlD,EAAK,EAAL,EoB8MU,E,QAIb,E,KAAa,E,KAAc,E,OpBlNI,E,EoBkNJ,G,EpBlN0B,CAAlD,EAAK,EAAL,EoBkNU,E,KACb,E,KAAkB,E,KAAJ,GAAe,EAAf,C,IAAyB,EAAJ,G,EAArB,E,EAAqB,GAAtB,C,QAab,E,KAAa,E,KAAc,E,OpBhOI,E,EoBgOJ,G,EpBhO0B,CAAlD,EAAK,EAAL,EoBgOU,E,KACb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,QAab,E,KAAa,E,KAAc,E,OpB9OI,E,EoB8OJ,G,EpB9O0B,CAAlD,EAAK,EAAL,EoB8OU,E,KACb,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAA2B,E,OpBrPhB,G,KoBsPX,E,KAA2B,E,OpBtPhB,G,QoByPX,E,KAAa,E,KAAc,E,OpBpPI,E,EoBoPJ,G,EpBpP0B,CAAlD,EAAK,EAAL,EoBoPU,E,KACb,E,KAAa,E,KAAc,E,OpBrPI,E,EoBqPJ,G,EpBrP0B,CAAlD,EAAK,EAAL,EoBqPU,E,KACb,E,KAAa,E,KAAc,E,OpBtPI,E,EoBsPJ,G,EpBtP0B,CAAlD,EAAK,EAAL,EoBsPU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBzMhB,G,QoB6MX,E,KAA2B,E,OpB7MhB,G,QoB2NX,E,KAAa,E,KAAc,E,OpBtNI,E,EoBsNJ,G,EpBtN0B,CAAlD,EAAK,EAAL,EoBsNU,E,KACb,E,KAA2B,E,OpB5NhB,G,QoByOX,E,KAAa,E,KAAc,E,OpBpOI,E,EoBoOJ,G,EpBpO0B,CAAlD,EAAK,EAAL,EoBoOU,E,KACb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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = -1;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n this.exitCode = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): i32 {\n if (interpreter === null) {\n return -1;\n }\n const int = interpreter;\n return int.exitCode || -1;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n if (logs) console.log(`Exit code: ${int.exitCode}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/release.wat b/build/release.wat index dc9125d..2560d97 100644 --- a/build/release.wat +++ b/build/release.wat @@ -28838,7 +28838,7 @@ local.get $3 i32.store offset=4 local.get $3 - i32.const 0 + i32.const -1 i32.store offset=24 global.get $~lib/memory/__stack_pointer local.get $3 @@ -30474,7 +30474,7 @@ local.get $0 i32.store local.get $0 - i32.const 0 + i32.const -1 i32.store offset=24 end global.get $~lib/memory/__stack_pointer @@ -31604,7 +31604,7 @@ i32.const 12 i32.add global.set $~lib/memory/__stack_pointer - i32.const 0 + i32.const -1 return end global.get $~lib/memory/__stack_pointer @@ -31632,7 +31632,7 @@ local.tee $0 i32.eqz if - i32.const 0 + i32.const -1 local.set $0 end global.get $~lib/memory/__stack_pointer diff --git a/build/test.wasm b/build/test.wasm index c893f4016987ad4e9d4a65e843c78c478f6a08af..3af31ef035e968e99a8ce48aecc5f2952e201887 100644 GIT binary patch delta 7270 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 Qck_IFB;3vdACOP}57R$?kpKVy delta 6866 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\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2dad002dad00?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 4096;\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16;\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = SEGMENT_SIZE;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE;\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n RawPage,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport {\n count_set_bits_32,\n count_set_bits_64,\n leading_zero_bits_32,\n leading_zero_bits_64,\n reverse_bytes,\n sign_extend_8,\n sign_extend_16,\n trailing_zero_bits_32,\n trailing_zero_bits_64,\n zero_extend_16,\n} from \"./bit\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"count_set_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 2 * 8 + 4);\n return assert;\n }),\n test(\"count_set_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 4);\n return assert;\n }),\n test(\"leading_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 16);\n return assert;\n }),\n test(\"leading_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 19);\n return assert;\n }),\n test(\"trailing_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 36);\n return assert;\n }),\n test(\"trailing_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 32);\n return assert;\n }),\n test(\"sign_extend_8\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_8(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_ffef);\n return assert;\n }),\n test(\"sign_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_beef);\n return assert;\n }),\n test(\"zero_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = zero_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0x0000_beef);\n return assert;\n }),\n test(\"reverse_bytes\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_dead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = reverse_bytes(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xefbe_adde_f0ff_0000);\n return assert;\n }),\n];\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","export class Test {\n constructor(\n public name: string,\n public ptr: (assert: Assert) => Assert,\n ) {}\n}\n\nexport class Assert {\n public isOkay: boolean = true;\n public errors: string[] = [];\n\n static todo(): Assert {\n const r = new Assert();\n r.fail(\"Not implemented yet!\");\n return r;\n }\n\n fail(msg: string): void {\n this.isOkay = false;\n this.errors.push(msg);\n }\n\n isArrayEqual(actual: T[], expected: T[], msg: string = \"\"): void {\n this.isEqual(actual.length, expected.length, `length @ ${msg}`);\n this.isEqual(actual.join(\",\").toString(), expected.join(\",\").toString(), msg);\n }\n\n isEqual(actual: T, expected: T, msg: string = \"\"): void {\n if (actual !== expected) {\n this.isOkay = false;\n const actualDisplay = isInteger(actual) ? `${actual} (0x${actual.toString(16)})` : `${actual}`;\n const expectDisplay = isInteger(expected) ? `${expected} (0x${expected.toString(16)})` : `${expected}`;\n this.errors.push(`Got: '${actualDisplay}', expected: '${expectDisplay}' @ ${msg}`);\n }\n }\n}\n\nexport function test(name: string, ptr: (assert: Assert) => Assert): Test {\n return new Test(name, ptr);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { branch_eq_imm } from \"./branch\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"branch_eq_imm\", () => {\n // when\n const args = new Args();\n args.a = 0;\n args.b = 0xfe;\n args.c = 0xdeadbeef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfe;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = branch_eq_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.StaticJump, \"outcome\");\n assert.isEqual(ret.staticJump, 0xdeadbeef, \"staticJump\");\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { and_inv, or_inv, xnor } from \"./logic\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"and_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = and_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_f000_0000_0000);\n return assert;\n }),\n test(\"or_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = or_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fff1);\n return assert;\n }),\n test(\"xnor\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0000;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = xnor(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_0fff_ffff_fff0);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport * as math from \"./math\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"max\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"max_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"add_32\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = 2 ** 64 - 1;\n regs[reg(args.b)] = 2 ** 64 - 1;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.add_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fffe);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { Outcome } from \"./outcome\";\nimport { rot_l_32, rot_l_64, rot_r_64_imm, rot_r_64_imm_alt } from \"./rot\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"rot_r_64_imm\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xef00_0000_00de_adbe);\n return assert;\n }),\n test(\"rot_r_64_imm_alt\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0xdead_beef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm_alt(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xefff_ffff_ffde_adbe);\n return assert;\n }),\n test(\"rot_l_64\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_00de_adbe_ef00);\n return assert;\n }),\n test(\"rot_l_32\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_adbe_efde);\n return assert;\n }),\n];\n","import { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY, RESERVED_PAGES } from \"./memory-page\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"Show fail when accessing any of the initial 16 pages\", () => {\n const mem = new MemoryBuilder().build();\n\n const a = mem.getI8(0);\n const b = mem.getU64(RESERVED_MEMORY - 1);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, true, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.fault.fault, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 61440);\n return assert;\n }),\n test(\"Show fail on missing page or invalid access\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Read, RESERVED_MEMORY, new Uint8Array(10));\n const mem = builder.build();\n\n const a = mem.getU64(RESERVED_MEMORY);\n const b = mem.getU8((RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT);\n const c = mem.setU8(RESERVED_MEMORY, 12);\n const d = mem.getU8(RESERVED_MEMORY);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, false, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.ok, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 69632);\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, true, \"c.access\");\n assert.isEqual(c.fault, 65536);\n assert.isEqual(d.ok, 0);\n return assert;\n }),\n test(\"should read and write across pages\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Write, RESERVED_MEMORY, new Uint8Array(1));\n builder.setData(Access.Write, (RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT, new Uint8Array(1));\n const mem = builder.build();\n\n const out = new Uint8Array(16);\n const data = new Uint8Array(out.length);\n data.set([0xde, 0xad, 0xbe, 0xef], 0);\n\n const a = mem.bytesWrite(RESERVED_MEMORY + PAGE_SIZE - 10, data);\n const b = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE - 9, out);\n const c = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE * 2, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(a.isAccess, false, \"a.access\");\n assert.isEqual(a.fault, 0, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(b.isAccess, false, \"b.access\");\n assert.isEqual(b.fault, 0, \"b.fault\");\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, false, \"c.access\");\n assert.isEqual(out.toString(), \"173,190,239,0,0,0,0,0,0,0,0,0,0,0,0,0\");\n assert.isEqual(data.toString(), \"222,173,190,239,0,0,0,0,0,0,0,0,0,0,0,0\");\n return assert;\n }),\n test(\"should allow 0-bytes reads and writes everywhere\", () => {\n const mem = new MemoryBuilder().setData(Access.Read, RESERVED_MEMORY, new Uint8Array(0)).build();\n\n const out = new Uint8Array(0);\n\n // reserved pages\n const a = mem.bytesRead(0, out);\n const b = mem.bytesWrite(0, out);\n\n // not allocated\n const c = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n const d = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n\n // readable page\n const e = mem.bytesWrite(RESERVED_MEMORY, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(c.isFault, false, \"c.fault\");\n assert.isEqual(d.isFault, false, \"d.fault\");\n assert.isEqual(e.isFault, false, \"e.fault\");\n return assert;\n }),\n];\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, dJump, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import { InstructionRun, hostCall, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport * as mov from \"./instructions/mov\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nimport { INVALID, ecalli, fallthrough, sbrk, trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n isStartOrEnd[0] = BasicBlock.START;\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { Arguments } from \"./arguments\";\nimport { RUN } from \"./instructions-exe\";\nimport { jump_ind } from \"./instructions/jump\";\nimport { trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport { BasicBlocks, JumpTable, Mask, deblob, decodeArguments } from \"./program\";\nimport { Assert, Test, test } from \"./test\";\n\nexport function u8arr(data: number[]): Uint8Array {\n const ret = new Uint8Array(data.length);\n ret.set(data, 0);\n return ret;\n}\n\nexport const TESTS: Test[] = [\n test(\"should parse packed mask correctly\", () => {\n const mask = new Mask(u8arr([0b0001_0000, 0b1000_0000, 0b1111_1000]), 21);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [4, 3, 2, 1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 3, 2, 1, 0, 0],\n );\n\n assert.isEqual(mask.isInstruction(0), false);\n assert.isEqual(mask.isInstruction(4), true);\n\n assert.isEqual(mask.skipBytesToNextInstruction(20), 0);\n assert.isEqual(mask.skipBytesToNextInstruction(22), 0);\n return assert;\n }),\n\n test(\"should not allow skipping more than 24 bytes\", () => {\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [\n 0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,\n 1, 0,\n ],\n );\n return assert;\n }),\n\n test(\"should decode arguments correctly\", () => {\n const data = u8arr([0xff, 0xff, 0xff, 0xff]);\n const args = decodeArguments(Arguments.OneImm, data, 4);\n\n const assert = new Assert();\n assert.isEqual(args.a, -1, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should decode positive bounded by skip\", () => {\n const data = u8arr([0x05, 0x05]);\n const args = decodeArguments(Arguments.OneImm, data, 1);\n\n const assert = new Assert();\n assert.isEqual(args.a, 5, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should deblob program\", () => {\n const raw = u8arr([\n 0, 0, 33, 51, 8, 1, 51, 9, 1, 40, 3, 0, 149, 119, 255, 81, 7, 12, 100, 138, 200, 152, 8, 100, 169, 40, 243, 100,\n 135, 51, 8, 51, 9, 1, 50, 0, 73, 147, 82, 213, 0,\n ]);\n const program = deblob(raw);\n const assert = new Assert();\n assert.isEqual(\n program.mask.toString(),\n \"Mask[0, 2, 1, 0, 2, 1, 0, 1, 0, 0, 2, 1, 0, 2, 1, 0, 1, 0, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, ]\",\n );\n assert.isEqual(program.jumpTable.toString(), \"JumpTable[]\");\n assert.isEqual(\n program.basicBlocks.toString(),\n \"BasicBlocks[0 -> start, 6 -> end, 8 -> startend, 9 -> start, 12 -> end, 15 -> start, 22 -> end, 24 -> start, 30 -> end, 31 -> startend, ]\",\n );\n return assert;\n }),\n\n test(\"should construct basic blocks correctly based on skip\", () => {\n const code = u8arr([\n opcode(trap),\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n opcode(jump_ind),\n ]);\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n const basicBlocks = new BasicBlocks(code, mask);\n const assert = new Assert();\n assert.isEqual(\n mask.toString(),\n \"Mask[0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, ]\",\n );\n assert.isEqual(basicBlocks.toString(), \"BasicBlocks[0 -> startend, 26 -> start, 31 -> end, ]\");\n return assert;\n }),\n test(\"should parse jump table with large numbers\", () => {\n const jumpTable = new JumpTable(\n 10,\n u8arr([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 2, 2, 2, 0]),\n );\n const assert = new Assert();\n assert.isEqual(\n jumpTable.toString(),\n \"JumpTable[0 -> 18446744073709551615, 1 -> 18446744073709551615, 2 -> 18446744073709551615, ]\",\n );\n return assert;\n }),\n];\n\nfunction opcode(search: InstructionRun): number {\n const idx = RUN.indexOf(search);\n if (idx < 0) {\n throw new Error(\"Opcode not found in RUN table for instruction\");\n }\n return idx;\n}\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { Program, deblob } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const DATA_LENGTH: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - DATA_LENGTH;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = 2 ** 32 - 2 * SEGMENT_SIZE - DATA_LENGTH;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > DATA_LENGTH) {\n throw new Error(\"Arguments length too big\");\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { liftBytes } from \"./program\";\nimport { decodeSpi } from \"./spi\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"should decode standard program\", () => {\n const PROGRAM = liftBytes([\n 0x04, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0xab, 0xcd, 0xef, 0x01, 0x12, 0x34, 0x07, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x03, 0xc8, 0x87, 0x09, 0x01,\n ]);\n const ARGS = liftBytes([0x12, 0x34, 0x56]);\n\n const spi = decodeSpi(PROGRAM, ARGS);\n\n const assert = new Assert();\n assert.isEqual(\n spi.toString(),\n \"StandardProgram { program: Program { code: 200,135,9, mask: Mask[0, 2, 1, ], jumpTable: JumpTable[], basicBlocks: BasicBlocks[0 -> start, ] }, memory_pages: 7, registers: 4294901760,4278059008,0,0,0,0,0,4278124544,3,0,0,0,0 }\",\n );\n return assert;\n }),\n];\n","import * as bit from \"./instructions/bit.test\";\nimport * as branch from \"./instructions/branch.test\";\nimport * as logic from \"./instructions/logic.test\";\nimport * as math from \"./instructions/math.test\";\nimport * as rot from \"./instructions/rot.test\";\nimport * as memory from \"./memory.test\";\nimport * as program from \"./program.test\";\nimport * as spi from \"./spi.test\";\nimport { Assert, Test } from \"./test\";\n\nexport function runAllTests(): void {\n let a: u64 = 0;\n\n a += run(bit.TESTS, \"bit.ts\");\n a += run(branch.TESTS, \"branch.ts\");\n a += run(logic.TESTS, \"logic.ts\");\n a += run(math.TESTS, \"math.ts\");\n a += run(memory.TESTS, \"memory.ts\");\n a += run(program.TESTS, \"program.ts\");\n a += run(rot.TESTS, \"rot.ts\");\n a += run(spi.TESTS, \"spi.ts\");\n\n const okay = u32(a >> 32);\n const total = u32(a);\n\n printSummary(\"\\n\\nTotal\", okay, total);\n if (okay !== total) {\n throw new Error(\"Some tests failed.\");\n }\n}\n\nfunction run(tests: Test[], file: string): u64 {\n let ok = 0;\n console.log(`> ${file}`);\n for (let i = 0; i < tests.length; i++) {\n console.log(` >>> ${tests[i].name}`);\n const res = tests[i].ptr(new Assert());\n if (res.isOkay) {\n console.log(` <<< ${tests[i].name} ✅`);\n ok += 1;\n } else {\n for (let j = 0; j < res.errors.length; j++) {\n console.log(` ${res.errors[j]}`);\n }\n console.log(` <<< ${tests[i].name} 🔴`);\n }\n }\n\n printSummary(`< ${file}`, ok, tests.length);\n\n return (u64(ok) << 32) + tests.length;\n}\n\nfunction printSummary(msg: string, okay: u32, total: u32): void {\n const ico = okay === total ? \"✅\" : \"🔴\";\n console.log(`${msg} ${okay} / ${total} ${ico}`);\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file +{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/bit.test.ts","~lib/util/hash.ts","~lib/map.ts","~lib/array.ts","assembly/test.ts","~lib/number.ts","~lib/string.ts","assembly/instructions/branch.ts","assembly/instructions/branch.test.ts","assembly/instructions/logic.ts","assembly/instructions/logic.test.ts","assembly/instructions/math.ts","assembly/instructions/math.test.ts","assembly/instructions/rot.ts","assembly/instructions/rot.test.ts","assembly/memory.test.ts","~lib/util/bytes.ts","~lib/console.ts","assembly/instructions/jump.ts","assembly/instructions/misc.ts","assembly/instructions/load.ts","assembly/instructions/mov.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/instructions.ts","assembly/program.ts","assembly/program.test.ts","assembly/spi.ts","assembly/spi.test.ts","assembly/test-run.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./test","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport {\n count_set_bits_32,\n count_set_bits_64,\n leading_zero_bits_32,\n leading_zero_bits_64,\n reverse_bytes,\n sign_extend_8,\n sign_extend_16,\n trailing_zero_bits_32,\n trailing_zero_bits_64,\n zero_extend_16,\n} from \"./bit\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"count_set_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 2 * 8 + 4);\n return assert;\n }),\n test(\"count_set_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 4);\n return assert;\n }),\n test(\"leading_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 16);\n return assert;\n }),\n test(\"leading_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 19);\n return assert;\n }),\n test(\"trailing_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 36);\n return assert;\n }),\n test(\"trailing_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 32);\n return assert;\n }),\n test(\"sign_extend_8\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_8(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_ffef);\n return assert;\n }),\n test(\"sign_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_beef);\n return assert;\n }),\n test(\"zero_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = zero_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0x0000_beef);\n return assert;\n }),\n test(\"reverse_bytes\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_dead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = reverse_bytes(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xefbe_adde_f0ff_0000);\n return assert;\n }),\n];\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","export class Test {\n constructor(\n public name: string,\n public ptr: (assert: Assert) => Assert,\n ) {}\n}\n\nexport class Assert {\n public isOkay: boolean = true;\n public errors: string[] = [];\n\n static todo(): Assert {\n const r = new Assert();\n r.fail(\"Not implemented yet!\");\n return r;\n }\n\n fail(msg: string): void {\n this.isOkay = false;\n this.errors.push(msg);\n }\n\n isArrayEqual(actual: T[], expected: T[], msg: string = \"\"): void {\n this.isEqual(actual.length, expected.length, `length @ ${msg}`);\n this.isEqual(actual.join(\",\").toString(), expected.join(\",\").toString(), msg);\n }\n\n isEqual(actual: T, expected: T, msg: string = \"\"): void {\n if (actual !== expected) {\n this.isOkay = false;\n const actualDisplay = isInteger(actual) ? `${actual} (0x${actual.toString(16)})` : `${actual}`;\n const expectDisplay = isInteger(expected) ? `${expected} (0x${expected.toString(16)})` : `${expected}`;\n this.errors.push(`Got: '${actualDisplay}', expected: '${expectDisplay}' @ ${msg}`);\n }\n }\n}\n\nexport function test(name: string, ptr: (assert: Assert) => Assert): Test {\n return new Test(name, ptr);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { branch_eq_imm } from \"./branch\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"branch_eq_imm\", () => {\n // when\n const args = new Args();\n args.a = 0;\n args.b = 0xfe;\n args.c = 0xdeadbeef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfe;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = branch_eq_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.StaticJump, \"outcome\");\n assert.isEqual(ret.staticJump, 0xdeadbeef, \"staticJump\");\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { and_inv, or_inv, xnor } from \"./logic\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"and_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = and_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_f000_0000_0000);\n return assert;\n }),\n test(\"or_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = or_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fff1);\n return assert;\n }),\n test(\"xnor\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0000;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = xnor(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_0fff_ffff_fff0);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport * as math from \"./math\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"max\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"max_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"add_32\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = 2 ** 64 - 1;\n regs[reg(args.b)] = 2 ** 64 - 1;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.add_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fffe);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { Outcome } from \"./outcome\";\nimport { rot_l_32, rot_l_64, rot_r_64_imm, rot_r_64_imm_alt } from \"./rot\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"rot_r_64_imm\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xef00_0000_00de_adbe);\n return assert;\n }),\n test(\"rot_r_64_imm_alt\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0xdead_beef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm_alt(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xefff_ffff_ffde_adbe);\n return assert;\n }),\n test(\"rot_l_64\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_00de_adbe_ef00);\n return assert;\n }),\n test(\"rot_l_32\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_adbe_efde);\n return assert;\n }),\n];\n","import { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY, RESERVED_PAGES } from \"./memory-page\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"Show fail when accessing any of the initial 16 pages\", () => {\n const mem = new MemoryBuilder().build();\n\n const a = mem.getI8(0);\n const b = mem.getU64(RESERVED_MEMORY - 1);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, true, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.fault.fault, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 61440);\n return assert;\n }),\n test(\"Show fail on missing page or invalid access\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Read, RESERVED_MEMORY, new Uint8Array(10));\n const mem = builder.build();\n\n const a = mem.getU64(RESERVED_MEMORY);\n const b = mem.getU8((RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT);\n const c = mem.setU8(RESERVED_MEMORY, 12);\n const d = mem.getU8(RESERVED_MEMORY);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, false, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.ok, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 69632);\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, true, \"c.access\");\n assert.isEqual(c.fault, 65536);\n assert.isEqual(d.ok, 0);\n return assert;\n }),\n test(\"should read and write across pages\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Write, RESERVED_MEMORY, new Uint8Array(1));\n builder.setData(Access.Write, (RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT, new Uint8Array(1));\n const mem = builder.build();\n\n const out = new Uint8Array(16);\n const data = new Uint8Array(out.length);\n data.set([0xde, 0xad, 0xbe, 0xef], 0);\n\n const a = mem.bytesWrite(RESERVED_MEMORY + PAGE_SIZE - 10, data);\n const b = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE - 9, out);\n const c = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE * 2, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(a.isAccess, false, \"a.access\");\n assert.isEqual(a.fault, 0, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(b.isAccess, false, \"b.access\");\n assert.isEqual(b.fault, 0, \"b.fault\");\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, false, \"c.access\");\n assert.isEqual(out.toString(), \"173,190,239,0,0,0,0,0,0,0,0,0,0,0,0,0\");\n assert.isEqual(data.toString(), \"222,173,190,239,0,0,0,0,0,0,0,0,0,0,0,0\");\n return assert;\n }),\n test(\"should allow 0-bytes reads and writes everywhere\", () => {\n const mem = new MemoryBuilder().setData(Access.Read, RESERVED_MEMORY, new Uint8Array(0)).build();\n\n const out = new Uint8Array(0);\n\n // reserved pages\n const a = mem.bytesRead(0, out);\n const b = mem.bytesWrite(0, out);\n\n // not allocated\n const c = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n const d = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n\n // readable page\n const e = mem.bytesWrite(RESERVED_MEMORY, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(c.isFault, false, \"c.fault\");\n assert.isEqual(d.isFault, false, \"d.fault\");\n assert.isEqual(e.isFault, false, \"e.fault\");\n return assert;\n }),\n];\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { Arguments } from \"./arguments\";\nimport { jump_ind } from \"./instructions/jump\";\nimport { trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport { RUN } from \"./instructions-exe\";\nimport { BasicBlocks, deblob, decodeArguments, JumpTable, Mask } from \"./program\";\nimport { Assert, Test, test } from \"./test\";\n\nexport function u8arr(data: number[]): Uint8Array {\n const ret = new Uint8Array(data.length);\n ret.set(data, 0);\n return ret;\n}\n\nexport const TESTS: Test[] = [\n test(\"should parse packed mask correctly\", () => {\n const mask = new Mask(u8arr([0b0001_0000, 0b1000_0000, 0b1111_1000]), 21);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [4, 3, 2, 1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 3, 2, 1, 0, 0],\n );\n\n assert.isEqual(mask.isInstruction(0), false);\n assert.isEqual(mask.isInstruction(4), true);\n\n assert.isEqual(mask.skipBytesToNextInstruction(20), 0);\n assert.isEqual(mask.skipBytesToNextInstruction(22), 0);\n return assert;\n }),\n\n test(\"should not allow skipping more than 24 bytes\", () => {\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [\n 0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,\n 1, 0,\n ],\n );\n return assert;\n }),\n\n test(\"should decode arguments correctly\", () => {\n const data = u8arr([0xff, 0xff, 0xff, 0xff]);\n const args = decodeArguments(Arguments.OneImm, data, 4);\n\n const assert = new Assert();\n assert.isEqual(args.a, -1, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should decode positive bounded by skip\", () => {\n const data = u8arr([0x05, 0x05]);\n const args = decodeArguments(Arguments.OneImm, data, 1);\n\n const assert = new Assert();\n assert.isEqual(args.a, 5, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should deblob program\", () => {\n const raw = u8arr([\n 0, 0, 33, 51, 8, 1, 51, 9, 1, 40, 3, 0, 149, 119, 255, 81, 7, 12, 100, 138, 200, 152, 8, 100, 169, 40, 243, 100,\n 135, 51, 8, 51, 9, 1, 50, 0, 73, 147, 82, 213, 0,\n ]);\n const program = deblob(raw);\n const assert = new Assert();\n assert.isEqual(\n program.mask.toString(),\n \"Mask[0, 2, 1, 0, 2, 1, 0, 1, 0, 0, 2, 1, 0, 2, 1, 0, 1, 0, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, ]\",\n );\n assert.isEqual(program.jumpTable.toString(), \"JumpTable[]\");\n assert.isEqual(\n program.basicBlocks.toString(),\n \"BasicBlocks[0 -> start, 6 -> end, 8 -> startend, 9 -> start, 12 -> end, 15 -> start, 22 -> end, 24 -> start, 30 -> end, 31 -> startend, ]\",\n );\n return assert;\n }),\n\n test(\"should construct basic blocks correctly based on skip\", () => {\n const code = u8arr([\n opcode(trap),\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n opcode(jump_ind),\n ]);\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n const basicBlocks = new BasicBlocks(code, mask);\n const assert = new Assert();\n assert.isEqual(\n mask.toString(),\n \"Mask[0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, ]\",\n );\n assert.isEqual(basicBlocks.toString(), \"BasicBlocks[0 -> startend, 26 -> start, 31 -> end, ]\");\n return assert;\n }),\n test(\"should parse jump table with large numbers\", () => {\n const jumpTable = new JumpTable(\n 10,\n u8arr([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 2, 2, 2, 0]),\n );\n const assert = new Assert();\n assert.isEqual(\n jumpTable.toString(),\n \"JumpTable[0 -> 18446744073709551615, 1 -> 18446744073709551615, 2 -> 18446744073709551615, ]\",\n );\n return assert;\n }),\n];\n\nfunction opcode(search: InstructionRun): number {\n const idx = RUN.indexOf(search);\n if (idx < 0) {\n throw new Error(\"Opcode not found in RUN table for instruction\");\n }\n return idx;\n}\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { liftBytes } from \"./program\";\nimport { decodeSpi } from \"./spi\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"should decode standard program\", () => {\n const PROGRAM = liftBytes([\n 0x04, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0xab, 0xcd, 0xef, 0x01, 0x12, 0x34, 0x07, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x03, 0xc8, 0x87, 0x09, 0x01,\n ]);\n const ARGS = liftBytes([0x12, 0x34, 0x56]);\n\n const spi = decodeSpi(PROGRAM, ARGS);\n\n const assert = new Assert();\n assert.isEqual(\n spi.toString(),\n \"StandardProgram { program: Program { code: 200,135,9, mask: Mask[0, 2, 1, ], jumpTable: JumpTable[], basicBlocks: BasicBlocks[0 -> start, ] }, memory_pages: 7, registers: 4294901760,4278059008,0,0,0,0,0,4278124544,3,0,0,0,0 }\",\n );\n return assert;\n }),\n];\n","import * as bit from \"./instructions/bit.test\";\nimport * as branch from \"./instructions/branch.test\";\nimport * as logic from \"./instructions/logic.test\";\nimport * as math from \"./instructions/math.test\";\nimport * as rot from \"./instructions/rot.test\";\nimport * as memory from \"./memory.test\";\nimport * as program from \"./program.test\";\nimport * as spi from \"./spi.test\";\nimport { Assert, Test } from \"./test\";\n\nexport function runAllTests(): void {\n let a: u64 = 0;\n\n a += run(bit.TESTS, \"bit.ts\");\n a += run(branch.TESTS, \"branch.ts\");\n a += run(logic.TESTS, \"logic.ts\");\n a += run(math.TESTS, \"math.ts\");\n a += run(memory.TESTS, \"memory.ts\");\n a += run(program.TESTS, \"program.ts\");\n a += run(rot.TESTS, \"rot.ts\");\n a += run(spi.TESTS, \"spi.ts\");\n\n const okay = u32(a >> 32);\n const total = u32(a);\n\n printSummary(\"\\n\\nTotal\", okay, total);\n if (okay !== total) {\n throw new Error(\"Some tests failed.\");\n }\n}\n\nfunction run(tests: Test[], file: string): u64 {\n let ok = 0;\n console.log(`> ${file}`);\n for (let i = 0; i < tests.length; i++) {\n console.log(` >>> ${tests[i].name}`);\n const res = tests[i].ptr(new Assert());\n if (res.isOkay) {\n console.log(` <<< ${tests[i].name} ✅`);\n ok += 1;\n } else {\n for (let j = 0; j < res.errors.length; j++) {\n console.log(` ${res.errors[j]}`);\n }\n console.log(` <<< ${tests[i].name} 🔴`);\n }\n }\n\n printSummary(`< ${file}`, ok, tests.length);\n\n return (u64(ok) << 32) + tests.length;\n}\n\nfunction printSummary(msg: string, okay: u32, total: u32): void {\n const ico = okay === total ? \"✅\" : \"🔴\";\n console.log(`${msg} ${okay} / ${total} ${ico}`);\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/test.wat b/build/test.wat index c8dd9d6..313c8de 100644 --- a/build/test.wat +++ b/build/test.wat @@ -63,9 +63,9 @@ (global $assembly/arguments/DECODERS i32 (i32.const 1248)) (global $assembly/registers/NO_OF_REGISTERS i32 (i32.const 13)) (global $assembly/registers/REG_SIZE_BYTES i32 (i32.const 8)) - (global $assembly/memory-page/PAGE_SIZE i32 (i32.const 4096)) - (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) (global $~lib/native/ASC_SHRINK_LEVEL i32 (i32.const 0)) + (global $assembly/memory-page/PAGE_SIZE (mut i32) (i32.const 0)) + (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) (global $assembly/memory-page/SEGMENT_SIZE (mut i32) (i32.const 0)) (global $assembly/memory-page/SEGMENT_SIZE_SHIFT i32 (i32.const 16)) (global $assembly/memory-page/RESERVED_MEMORY (mut i32) (i32.const 0)) @@ -171,74 +171,74 @@ (global $assembly/instructions/jump/jump_ind i32 (i32.const 10608)) (global $assembly/instructions/jump/load_imm_jump i32 (i32.const 10640)) (global $assembly/instructions/jump/load_imm_jump_ind i32 (i32.const 10672)) - (global $assembly/instructions/load/load_imm_64 i32 (i32.const 10704)) - (global $assembly/instructions/load/load_imm i32 (i32.const 10736)) - (global $assembly/instructions/load/load_u8 i32 (i32.const 10768)) - (global $assembly/instructions/load/load_i8 i32 (i32.const 10800)) - (global $assembly/instructions/load/load_u16 i32 (i32.const 10832)) - (global $assembly/instructions/load/load_i16 i32 (i32.const 10864)) - (global $assembly/instructions/load/load_u32 i32 (i32.const 10896)) - (global $assembly/instructions/load/load_i32 i32 (i32.const 10928)) - (global $assembly/instructions/load/load_u64 i32 (i32.const 10960)) - (global $assembly/instructions/load/load_ind_u8 i32 (i32.const 10992)) - (global $assembly/instructions/load/load_ind_i8 i32 (i32.const 11024)) - (global $assembly/instructions/load/load_ind_u16 i32 (i32.const 11056)) - (global $assembly/instructions/load/load_ind_i16 i32 (i32.const 11088)) - (global $assembly/instructions/load/load_ind_u32 i32 (i32.const 11120)) - (global $assembly/instructions/load/load_ind_i32 i32 (i32.const 11152)) - (global $assembly/instructions/load/load_ind_u64 i32 (i32.const 11184)) - (global $assembly/instructions/mov/move_reg i32 (i32.const 11216)) - (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11248)) - (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11280)) - (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11312)) - (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11344)) - (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 11376)) - (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 11408)) - (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 11440)) - (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 11472)) - (global $assembly/instructions/set/set_lt_u i32 (i32.const 11504)) - (global $assembly/instructions/set/set_lt_s i32 (i32.const 11536)) + (global $assembly/instructions/misc/INVALID i32 (i32.const 10704)) + (global $assembly/instructions/misc/trap i32 (i32.const 10736)) + (global $assembly/instructions/misc/fallthrough i32 (i32.const 10768)) + (global $assembly/instructions/misc/ecalli i32 (i32.const 10800)) + (global $assembly/instructions/misc/sbrk i32 (i32.const 10832)) + (global $assembly/instructions/load/load_imm_64 i32 (i32.const 10864)) + (global $assembly/instructions/load/load_imm i32 (i32.const 10896)) + (global $assembly/instructions/load/load_u8 i32 (i32.const 10928)) + (global $assembly/instructions/load/load_i8 i32 (i32.const 10960)) + (global $assembly/instructions/load/load_u16 i32 (i32.const 10992)) + (global $assembly/instructions/load/load_i16 i32 (i32.const 11024)) + (global $assembly/instructions/load/load_u32 i32 (i32.const 11056)) + (global $assembly/instructions/load/load_i32 i32 (i32.const 11088)) + (global $assembly/instructions/load/load_u64 i32 (i32.const 11120)) + (global $assembly/instructions/load/load_ind_u8 i32 (i32.const 11152)) + (global $assembly/instructions/load/load_ind_i8 i32 (i32.const 11184)) + (global $assembly/instructions/load/load_ind_u16 i32 (i32.const 11216)) + (global $assembly/instructions/load/load_ind_i16 i32 (i32.const 11248)) + (global $assembly/instructions/load/load_ind_u32 i32 (i32.const 11280)) + (global $assembly/instructions/load/load_ind_i32 i32 (i32.const 11312)) + (global $assembly/instructions/load/load_ind_u64 i32 (i32.const 11344)) + (global $assembly/instructions/mov/move_reg i32 (i32.const 11376)) + (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11408)) + (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11440)) + (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11472)) + (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11504)) + (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 11536)) + (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 11568)) + (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 11600)) + (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 11632)) + (global $assembly/instructions/set/set_lt_u i32 (i32.const 11664)) + (global $assembly/instructions/set/set_lt_s i32 (i32.const 11696)) (global $assembly/instructions/shift/MAX_SHIFT_64 i32 (i32.const 64)) (global $assembly/instructions/shift/MAX_SHIFT_32 i32 (i32.const 32)) - (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 11568)) - (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 11600)) - (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 11632)) - (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 11664)) - (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 11696)) - (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 11728)) - (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 11760)) - (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 11792)) - (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 11824)) - (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 11856)) - (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 11888)) - (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 11920)) - (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 11952)) - (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 11984)) - (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12016)) - (global $assembly/instructions/shift/shlo_l i32 (i32.const 12048)) - (global $assembly/instructions/shift/shlo_r i32 (i32.const 12080)) - (global $assembly/instructions/shift/shar_r i32 (i32.const 12112)) - (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12144)) - (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12176)) - (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12208)) - (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12240)) - (global $assembly/instructions/store/store_u8 i32 (i32.const 12272)) - (global $assembly/instructions/store/store_u16 i32 (i32.const 12304)) - (global $assembly/instructions/store/store_u32 i32 (i32.const 12336)) - (global $assembly/instructions/store/store_u64 i32 (i32.const 12368)) - (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 12400)) - (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 12432)) - (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 12464)) - (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 12496)) - (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 12528)) - (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 12560)) - (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 12592)) - (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 12624)) - (global $assembly/instructions/misc/INVALID i32 (i32.const 12656)) - (global $assembly/instructions/misc/trap i32 (i32.const 12688)) - (global $assembly/instructions/misc/fallthrough i32 (i32.const 12720)) - (global $assembly/instructions/misc/ecalli i32 (i32.const 12752)) - (global $assembly/instructions/misc/sbrk i32 (i32.const 12784)) + (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 11728)) + (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 11760)) + (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 11792)) + (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 11824)) + (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 11856)) + (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 11888)) + (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 11920)) + (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 11952)) + (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 11984)) + (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 12016)) + (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 12048)) + (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 12080)) + (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 12112)) + (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 12144)) + (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12176)) + (global $assembly/instructions/shift/shlo_l i32 (i32.const 12208)) + (global $assembly/instructions/shift/shlo_r i32 (i32.const 12240)) + (global $assembly/instructions/shift/shar_r i32 (i32.const 12272)) + (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12304)) + (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12336)) + (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12368)) + (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12400)) + (global $assembly/instructions/store/store_u8 i32 (i32.const 12432)) + (global $assembly/instructions/store/store_u16 i32 (i32.const 12464)) + (global $assembly/instructions/store/store_u32 i32 (i32.const 12496)) + (global $assembly/instructions/store/store_u64 i32 (i32.const 12528)) + (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 12560)) + (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 12592)) + (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 12624)) + (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 12656)) + (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 12688)) + (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 12720)) + (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 12752)) + (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 12784)) (global $assembly/instructions-exe/RUN i32 (i32.const 13760)) (global $assembly/codec/MASKS i32 (i32.const 13840)) (global $assembly/codec/variableLength i32 (i32.const 13888)) @@ -250,14 +250,14 @@ (global $assembly/program/BasicBlock.START i32 (i32.const 2)) (global $assembly/program/BasicBlock.END i32 (i32.const 4)) (global $assembly/program.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/spi/DATA_LENGTH (mut i32) (i32.const 0)) + (global $assembly/spi/MAX_ARGS_LEN (mut i32) (i32.const 0)) (global $assembly/spi/ARGS_SEGMENT_START (mut i32) (i32.const 0)) (global $assembly/spi/STACK_SEGMENT_END (mut i32) (i32.const 0)) (global $assembly/spi.test/TESTS (mut i32) (i32.const 0)) - (global $~lib/rt/__rtti_base i32 (i32.const 27856)) - (global $~lib/memory/__data_end i32 (i32.const 28052)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 60820)) - (global $~lib/memory/__heap_base i32 (i32.const 60820)) + (global $~lib/rt/__rtti_base i32 (i32.const 27968)) + (global $~lib/memory/__data_end i32 (i32.const 28164)) + (global $~lib/memory/__stack_pointer (mut i32) (i32.const 60932)) + (global $~lib/memory/__heap_base i32 (i32.const 60932)) (memory $0 1) (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") @@ -540,7 +540,7 @@ (data $278 (i32.const 12700) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b2\00\00\00\00\00\00\00\00\00\00\00") (data $279 (i32.const 12732) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b3\00\00\00\00\00\00\00\00\00\00\00") (data $280 (i32.const 12764) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b4\00\00\00\00\00\00\00\00\00\00\00") - (data $281 (i32.const 12796) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00\901\00\00\b01\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d01\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d0)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p/\00\00\90/\00\00\b0/\00\00\d0/\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00P)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p)\00\00\f0)\00\00\10*\00\000*\00\00P*\00\00p*\00\00\90*\00\00\b0*\00\00\d0*\00\00\f0/\00\00\100\00\0000\00\00P0\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p0\00\00\900\00\00\b00\00\00\d00\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\90)\00\00@\15\00\00`\15\00\00\80\15\00\00\a0\15\00\00\c0\15\00\00\e0\15\00\00\00\16\00\00 \16\00\00@\16\00\00`\16\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\d0+\00\00\f01\00\00\c0\05\00\00\e0\05\00\00\00\06\00\00 \06\00\00@\06\00\00`\06\00\00\80\06\00\00\a0\06\00\00\c0\06\00\00\e0\06\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\f00\00\00\101\00\0001\00\00P1\00\00\f0*\00\00\10+\00\000+\00\00P+\00\00p+\00\00\90+\00\00\b0+\00\00@\1a\00\00P\18\00\00p\18\00\00\90\18\00\00`\1a\00\00p,\00\00\90,\00\000-\00\00P-\00\00p-\00\00\80\1a\00\00\b0,\00\00\d0,\00\00\90-\00\00\b0-\00\00\d0-\00\00\f0+\00\00\10,\00\00\a0\1a\00\00\c0\1a\00\00\f0-\00\00\10.\00\000.\00\00\e0\1a\00\00P.\00\00p.\00\00\90.\00\00\e0\1e\00\00\00\1f\00\00 \1f\00\00@\1f\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\80\16\00\00\a0\16\00\00\c0\16\00\00\e0\16\00\00\00\17\00\00 \17\00\00p1\00\00p1\00\00p1\00\00p1\00\00\b0)\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00p1\00\00\00\1b\00\00 \1b\00\00@\1b\00\00`\1b\00\00\80\1b\00\00\a0\1b\00\00\c0\1b\00\00\b0.\00\00\d0.\00\00\f0.\00\00\e0\1b\00\00\00\1c\00\00 \1c\00\00@\1c\00\00`\1c\00\00\80\1c\00\00\a0\1c\00\00\10/\00\000/\00\00P/\00\00\b0\18\00\00\d0\18\00\00\f0\18\00\00\c0\1c\00\00\e0\1c\00\00\00\1d\00\00\f0,\00\00\10-\00\000,\00\00P,\00\00`\1f\00\00\80\1f\00\00\a0\1f\00\00\c0\1f\00\00\10\19\00\000\19\00\00P\19\00\00 \1d\00\00@\1d\00\00`\1d\00\00\80\1d\00\00") + (data $281 (i32.const 12796) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00\f0)\00\00\10*\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\000*\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00p*\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\100\00\0000\00\00P0\00\00p0\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00P)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00p)\00\00\90*\00\00\b0*\00\00\d0*\00\00\f0*\00\00\10+\00\000+\00\00P+\00\00p+\00\00\900\00\00\b00\00\00\d00\00\00\f00\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\101\00\0001\00\00P1\00\00p1\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\90)\00\00@\15\00\00`\15\00\00\80\15\00\00\a0\15\00\00\c0\15\00\00\e0\15\00\00\00\16\00\00 \16\00\00@\16\00\00`\16\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00p,\00\00P*\00\00\c0\05\00\00\e0\05\00\00\00\06\00\00 \06\00\00@\06\00\00`\06\00\00\80\06\00\00\a0\06\00\00\c0\06\00\00\e0\06\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\901\00\00\b01\00\00\d01\00\00\f01\00\00\90+\00\00\b0+\00\00\d0+\00\00\f0+\00\00\10,\00\000,\00\00P,\00\00@\1a\00\00P\18\00\00p\18\00\00\90\18\00\00`\1a\00\00\10-\00\000-\00\00\d0-\00\00\f0-\00\00\10.\00\00\80\1a\00\00P-\00\00p-\00\000.\00\00P.\00\00p.\00\00\90,\00\00\b0,\00\00\a0\1a\00\00\c0\1a\00\00\90.\00\00\b0.\00\00\d0.\00\00\e0\1a\00\00\f0.\00\00\10/\00\000/\00\00\e0\1e\00\00\00\1f\00\00 \1f\00\00@\1f\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\80\16\00\00\a0\16\00\00\c0\16\00\00\e0\16\00\00\00\17\00\00 \17\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\b0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\00\1b\00\00 \1b\00\00@\1b\00\00`\1b\00\00\80\1b\00\00\a0\1b\00\00\c0\1b\00\00P/\00\00p/\00\00\90/\00\00\e0\1b\00\00\00\1c\00\00 \1c\00\00@\1c\00\00`\1c\00\00\80\1c\00\00\a0\1c\00\00\b0/\00\00\d0/\00\00\f0/\00\00\b0\18\00\00\d0\18\00\00\f0\18\00\00\c0\1c\00\00\e0\1c\00\00\00\1d\00\00\90-\00\00\b0-\00\00\d0,\00\00\f0,\00\00`\1f\00\00\80\1f\00\00\a0\1f\00\00\c0\1f\00\00\10\19\00\000\19\00\00P\19\00\00 \1d\00\00@\1d\00\00`\1d\00\00\80\1d\00\00") (data $282 (i32.const 13740) ",\00\00\00\00\00\00\00\00\00\00\00!\00\00\00\10\00\00\00\102\00\00\102\00\00\9c\03\00\00\e7\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") (data $283 (i32.const 13788) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80\00\00\00\00") (data $284 (i32.const 13820) ",\00\00\00\00\00\00\00\00\00\00\00\"\00\00\00\10\00\00\00\f05\00\00\f05\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") @@ -742,49 +742,51 @@ (data $480 (i32.const 25372) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00<\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00s\00t\00a\00n\00d\00a\00r\00d\00 \00p\00r\00o\00g\00r\00a\00m\00") (data $481 (i32.const 25452) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\1c\00\00\00\04\00\00\02\00\00\03\00 \00\00\ab\cd\ef\01\124\07\00\00\00\00\00\03\c8\87\t\01") (data $482 (i32.const 25500) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\03\00\00\00\124V\00\00\00\00\00\00\00\00\00") - (data $483 (i32.const 25532) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00A\00r\00g\00u\00m\00e\00n\00t\00s\00 \00l\00e\00n\00g\00t\00h\00 \00t\00o\00o\00 \00b\00i\00g\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $484 (i32.const 25612) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00s\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $485 (i32.const 25676) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") - (data $486 (i32.const 25804) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00\00\00\00\00\00\00") - (data $487 (i32.const 25884) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $488 (i32.const 25948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \00\00\00") - (data $489 (i32.const 25996) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00}\00\00\00\00\00\00\00\00\00") - (data $490 (i32.const 26028) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00\e0d\00\00\00\00\00\000e\00\00\00\00\00\00pe\00\00\00\00\00\00\a0e\00\00") - (data $491 (i32.const 26076) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $492 (i32.const 26140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00m\00a\00s\00k\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $493 (i32.const 26188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00\00\00") - (data $494 (i32.const 26236) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $495 (i32.const 26300) "<\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00$\00\00\00\f0e\00\00\00\00\00\000f\00\00\00\00\00\00`f\00\00\00\00\00\00\90f\00\00\00\00\00\00\a0e\00\00\00\00\00\00\00\00\00\00") - (data $496 (i32.const 26364) "\dc\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\c2\01\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \002\000\000\00,\001\003\005\00,\009\00,\00 \00m\00a\00s\00k\00:\00 \00M\00a\00s\00k\00[\000\00,\00 \002\00,\00 \001\00,\00 \00]\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00]\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \00]\00 \00}\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \007\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \004\002\009\004\009\000\001\007\006\000\00,\004\002\007\008\000\005\009\000\000\008\00,\000\00,\000\00,\000\00,\000\00,\000\00,\004\002\007\008\001\002\004\005\004\004\00,\003\00,\000\00,\000\00,\000\00,\000\00 \00}\00\00\00\00\00\00\00\00\00\00\00") - (data $497 (i32.const 26844) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bd\00\00\00\00\00\00\00\00\00\00\00") - (data $498 (i32.const 26876) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00b\00i\00t\00.\00t\00s\00") - (data $499 (i32.const 26908) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00>\00 \00\00\00\00\00\00\00\00\00") - (data $500 (i32.const 26940) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00>\00>\00>\00 \00") - (data $501 (i32.const 26972) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00<\00<\00<\00 \00") - (data $502 (i32.const 27004) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00\05\'\00\00\00\00\00\00\00\00") - (data $503 (i32.const 27036) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00pi\00\00\00\00\00\00\90i\00\00") - (data $504 (i32.const 27068) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00 \00 \00 \00\00\00\00\00") - (data $505 (i32.const 27100) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00=\d84\dd\00\00\00\00\00\00") - (data $506 (i32.const 27132) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00pi\00\00\00\00\00\00\f0i\00\00") - (data $507 (i32.const 27164) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00<\00 \00\00\00\00\00\00\00\00\00") - (data $508 (i32.const 27196) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\05\'\00\00\00\00\00\00\00\00\00\00") - (data $509 (i32.const 27228) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00=\d84\dd\00\00\00\00\00\00\00\00") - (data $510 (i32.const 27260) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $511 (i32.const 27292) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00/\00 \00\00\00\00\00\00\00") - (data $512 (i32.const 27324) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00\00\00\00\00\90j\00\00\00\00\00\00\b0j\00\00\00\00\00\00\90j\00\00\00\00\00\00") - (data $513 (i32.const 27372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00b\00r\00a\00n\00c\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $514 (i32.const 27420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00l\00o\00g\00i\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $515 (i32.const 27468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00m\00a\00t\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $516 (i32.const 27516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $517 (i32.const 27564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $518 (i32.const 27612) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00r\00o\00t\00.\00t\00s\00") - (data $519 (i32.const 27644) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00s\00p\00i\00.\00t\00s\00") - (data $520 (i32.const 27676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00\n\00\n\00T\00o\00t\00a\00l\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $521 (i32.const 27724) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00S\00o\00m\00e\00 \00t\00e\00s\00t\00s\00 \00f\00a\00i\00l\00e\00d\00.\00\00\00\00\00\00\00\00\00") - (data $522 (i32.const 27788) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00t\00e\00s\00t\00-\00r\00u\00n\00.\00t\00s\00\00\00\00\00") - (data $523 (i32.const 27856) "0\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\02A\00\00\02A\00\00\00\00\00\00\04A\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00A\00\00\00\02A\00\00B\00\00\00\00\00\00\00\02\01\00\00\00\00\00\00$\01\00\00\02\1a\00\00\02\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\t\00\00\00\00\00\00 \00\00\00\00\00\00\00") + (data $483 (i32.const 25532) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00A\00r\00g\00u\00m\00e\00n\00t\00s\00 \00l\00e\00n\00g\00t\00h\00 \00i\00s\00 \00t\00o\00o\00 \00b\00i\00g\00.\00 \00G\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00") + (data $484 (i32.const 25628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00m\00a\00x\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $485 (i32.const 25676) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\d0c\00\00\00\00\00\000d\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $486 (i32.const 25724) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00s\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $487 (i32.const 25788) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") + (data $488 (i32.const 25916) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00\00\00\00\00\00\00") + (data $489 (i32.const 25996) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $490 (i32.const 26060) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \00\00\00") + (data $491 (i32.const 26108) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00}\00\00\00\00\00\00\00\00\00") + (data $492 (i32.const 26140) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00Pe\00\00\00\00\00\00\a0e\00\00\00\00\00\00\e0e\00\00\00\00\00\00\10f\00\00") + (data $493 (i32.const 26188) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $494 (i32.const 26252) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00m\00a\00s\00k\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $495 (i32.const 26300) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00\00\00") + (data $496 (i32.const 26348) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $497 (i32.const 26412) "<\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00$\00\00\00`f\00\00\00\00\00\00\a0f\00\00\00\00\00\00\d0f\00\00\00\00\00\00\00g\00\00\00\00\00\00\10f\00\00\00\00\00\00\00\00\00\00") + (data $498 (i32.const 26476) "\dc\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\c2\01\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \002\000\000\00,\001\003\005\00,\009\00,\00 \00m\00a\00s\00k\00:\00 \00M\00a\00s\00k\00[\000\00,\00 \002\00,\00 \001\00,\00 \00]\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00]\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \00]\00 \00}\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \007\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \004\002\009\004\009\000\001\007\006\000\00,\004\002\007\008\000\005\009\000\000\008\00,\000\00,\000\00,\000\00,\000\00,\000\00,\004\002\007\008\001\002\004\005\004\004\00,\003\00,\000\00,\000\00,\000\00,\000\00 \00}\00\00\00\00\00\00\00\00\00\00\00") + (data $499 (i32.const 26956) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bd\00\00\00\00\00\00\00\00\00\00\00") + (data $500 (i32.const 26988) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00b\00i\00t\00.\00t\00s\00") + (data $501 (i32.const 27020) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00>\00 \00\00\00\00\00\00\00\00\00") + (data $502 (i32.const 27052) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00>\00>\00>\00 \00") + (data $503 (i32.const 27084) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00<\00<\00<\00 \00") + (data $504 (i32.const 27116) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00\05\'\00\00\00\00\00\00\00\00") + (data $505 (i32.const 27148) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00\e0i\00\00\00\00\00\00\00j\00\00") + (data $506 (i32.const 27180) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00 \00 \00 \00\00\00\00\00") + (data $507 (i32.const 27212) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00=\d84\dd\00\00\00\00\00\00") + (data $508 (i32.const 27244) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00\e0i\00\00\00\00\00\00`j\00\00") + (data $509 (i32.const 27276) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00<\00 \00\00\00\00\00\00\00\00\00") + (data $510 (i32.const 27308) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\05\'\00\00\00\00\00\00\00\00\00\00") + (data $511 (i32.const 27340) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00=\d84\dd\00\00\00\00\00\00\00\00") + (data $512 (i32.const 27372) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") + (data $513 (i32.const 27404) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00/\00 \00\00\00\00\00\00\00") + (data $514 (i32.const 27436) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00\00\00\00\00\00k\00\00\00\00\00\00 k\00\00\00\00\00\00\00k\00\00\00\00\00\00") + (data $515 (i32.const 27484) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00b\00r\00a\00n\00c\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $516 (i32.const 27532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00l\00o\00g\00i\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $517 (i32.const 27580) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00m\00a\00t\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $518 (i32.const 27628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") + (data $519 (i32.const 27676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00\00\00") + (data $520 (i32.const 27724) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00r\00o\00t\00.\00t\00s\00") + (data $521 (i32.const 27756) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00s\00p\00i\00.\00t\00s\00") + (data $522 (i32.const 27788) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00\n\00\n\00T\00o\00t\00a\00l\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") + (data $523 (i32.const 27836) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00S\00o\00m\00e\00 \00t\00e\00s\00t\00s\00 \00f\00a\00i\00l\00e\00d\00.\00\00\00\00\00\00\00\00\00") + (data $524 (i32.const 27900) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00t\00e\00s\00t\00-\00r\00u\00n\00.\00t\00s\00\00\00\00\00") + (data $525 (i32.const 27968) "0\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\02A\00\00\02A\00\00\00\00\00\00\04A\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00A\00\00\00\02A\00\00B\00\00\00\00\00\00\00\02\01\00\00\00\00\00\00$\01\00\00\02\1a\00\00\02\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\t\00\00\00\00\00\00 \00\00\00\00\00\00\00") (table $0 190 190 funcref) - (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/bit.test~anonymous|0 $start:assembly/instructions/bit.test~anonymous|1 $start:assembly/instructions/bit.test~anonymous|2 $start:assembly/instructions/bit.test~anonymous|3 $start:assembly/instructions/bit.test~anonymous|4 $start:assembly/instructions/bit.test~anonymous|5 $start:assembly/instructions/bit.test~anonymous|6 $start:assembly/instructions/bit.test~anonymous|7 $start:assembly/instructions/bit.test~anonymous|8 $start:assembly/instructions/bit.test~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/branch.test~anonymous|0 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/logic.test~anonymous|0 $start:assembly/instructions/logic.test~anonymous|1 $start:assembly/instructions/logic.test~anonymous|2 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/math.test~anonymous|0 $start:assembly/instructions/math.test~anonymous|1 $start:assembly/instructions/math.test~anonymous|2 $start:assembly/instructions/math.test~anonymous|3 $start:assembly/instructions/math.test~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/rot.test~anonymous|0 $start:assembly/instructions/rot.test~anonymous|1 $start:assembly/instructions/rot.test~anonymous|2 $start:assembly/instructions/rot.test~anonymous|3 $start:assembly/memory.test~anonymous|0 $start:assembly/memory.test~anonymous|1 $start:assembly/memory.test~anonymous|2 $start:assembly/memory.test~anonymous|3 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/codec~anonymous|0 $start:assembly/program.test~anonymous|0 $start:assembly/program.test~anonymous|1 $start:assembly/program.test~anonymous|2 $start:assembly/program.test~anonymous|3 $start:assembly/program.test~anonymous|4 $start:assembly/program.test~anonymous|5 $start:assembly/program.test~anonymous|6 $start:assembly/spi.test~anonymous|0) + (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/bit.test~anonymous|0 $start:assembly/instructions/bit.test~anonymous|1 $start:assembly/instructions/bit.test~anonymous|2 $start:assembly/instructions/bit.test~anonymous|3 $start:assembly/instructions/bit.test~anonymous|4 $start:assembly/instructions/bit.test~anonymous|5 $start:assembly/instructions/bit.test~anonymous|6 $start:assembly/instructions/bit.test~anonymous|7 $start:assembly/instructions/bit.test~anonymous|8 $start:assembly/instructions/bit.test~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/branch.test~anonymous|0 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/logic.test~anonymous|0 $start:assembly/instructions/logic.test~anonymous|1 $start:assembly/instructions/logic.test~anonymous|2 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/math.test~anonymous|0 $start:assembly/instructions/math.test~anonymous|1 $start:assembly/instructions/math.test~anonymous|2 $start:assembly/instructions/math.test~anonymous|3 $start:assembly/instructions/math.test~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/rot.test~anonymous|0 $start:assembly/instructions/rot.test~anonymous|1 $start:assembly/instructions/rot.test~anonymous|2 $start:assembly/instructions/rot.test~anonymous|3 $start:assembly/memory.test~anonymous|0 $start:assembly/memory.test~anonymous|1 $start:assembly/memory.test~anonymous|2 $start:assembly/memory.test~anonymous|3 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/codec~anonymous|0 $start:assembly/program.test~anonymous|0 $start:assembly/program.test~anonymous|1 $start:assembly/program.test~anonymous|2 $start:assembly/program.test~anonymous|3 $start:assembly/program.test~anonymous|4 $start:assembly/program.test~anonymous|5 $start:assembly/program.test~anonymous|6 $start:assembly/spi.test~anonymous|0) (export "runAllTests" (func $assembly/test-run/runAllTests)) (export "memory" (memory $0)) (start $~start) @@ -3363,11 +3365,17 @@ return ) (func $start:assembly/memory-page + i32.const 2 + i32.const 12 + call $~lib/math/ipow32 + global.set $assembly/memory-page/PAGE_SIZE i32.const 2 i32.const 16 call $~lib/math/ipow32 global.set $assembly/memory-page/SEGMENT_SIZE - global.get $assembly/memory-page/SEGMENT_SIZE + i32.const 2 + i32.const 16 + call $~lib/math/ipow32 global.set $assembly/memory-page/RESERVED_MEMORY global.get $assembly/memory-page/RESERVED_MEMORY global.get $assembly/memory-page/PAGE_SIZE @@ -5940,23 +5948,17 @@ i32.const 2 i32.const 24 call $~lib/math/ipow32 - global.set $assembly/spi/DATA_LENGTH + global.set $assembly/spi/MAX_ARGS_LEN i32.const 2 i32.const 32 call $~lib/math/ipow32 global.get $assembly/memory-page/SEGMENT_SIZE i32.sub - global.get $assembly/spi/DATA_LENGTH + global.get $assembly/spi/MAX_ARGS_LEN i32.sub global.set $assembly/spi/ARGS_SEGMENT_START - i32.const 2 - i32.const 32 - call $~lib/math/ipow32 - i32.const 2 + global.get $assembly/spi/ARGS_SEGMENT_START global.get $assembly/memory-page/SEGMENT_SIZE - i32.mul - i32.sub - global.get $assembly/spi/DATA_LENGTH i32.sub global.set $assembly/spi/STACK_SEGMENT_END ) @@ -7047,8 +7049,8 @@ global.get $~lib/memory/__data_end i32.lt_s if - i32.const 60848 - i32.const 60896 + i32.const 60960 + i32.const 61008 i32.const 1 i32.const 1 call $~lib/builtins/abort @@ -27384,8 +27386,9 @@ local.get $4 return ) - (func $start:assembly/instructions/load~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) + (func $assembly/instructions/outcome/status (param $result i32) (result i32) + (local $r i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -27394,52 +27397,39 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $registers - local.set $3 global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 + local.get $r + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $2 i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - local.get $args - local.set $3 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 global.get $~lib/memory/__stack_pointer - local.get $3 + local.get $2 i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.const 32 - i64.shl - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 + local.get $2 + local.get $result + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 global.get $~lib/memory/__stack_pointer i32.const 8 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $2 return ) - (func $start:assembly/instructions/load~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) + (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) + (local $r i32) + (local $2 i32) global.get $~lib/memory/__stack_pointer i32.const 8 i32.sub @@ -27448,37 +27438,275 @@ global.get $~lib/memory/__stack_pointer i64.const 0 i64.store - local.get $registers - local.set $3 global.get $~lib/memory/__stack_pointer - local.get $3 + i32.const 0 + call $assembly/instructions/outcome/OutcomeData#constructor + local.tee $r + i32.store + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Outcome.Result + call $assembly/instructions/outcome/OutcomeData#set:outcome + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + global.get $assembly/instructions/outcome/Result.HOST + call $assembly/instructions/outcome/OutcomeData#set:result + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + local.get $2 + i32.store offset=4 + local.get $2 + local.get $id + call $assembly/instructions/outcome/OutcomeData#set:exitCode + local.get $r + local.set $2 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $2 + return + ) + (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 i32.store - local.get $3 local.get $args local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 - i32.store offset=4 + i32.store local.get $3 call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args + call $assembly/instructions/outcome/hostCall local.set $3 global.get $~lib/memory/__stack_pointer + i32.const 4 + i32.add + global.set $~lib/memory/__stack_pointer local.get $3 + ) + (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) + (local $freeMemoryStart i32) + (local $newSbrk i64) + (local $pageIdx i32) + (local $i i32) + (local $page i32) + (local $7 i32) + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i32.const 0 + i32.const 20 + memory.fill + global.get $~lib/memory/__stack_pointer + i32.const 0 + call $assembly/memory/Result#constructor + local.tee $freeMemoryStart + i32.store + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 + local.get $7 + local.get $this + local.set $7 global.get $~lib/memory/__stack_pointer - i32.const 8 + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + call $assembly/memory/Result#set:ok + local.get $amount + i32.const 0 + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:sbrkAddress + i64.extend_i32_u + local.get $amount + i64.extend_i32_u + i64.add + local.set $newSbrk + local.get $newSbrk + global.get $assembly/memory/MEMORY_SIZE + i64.ge_s + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Result#get:fault + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + i32.const 1 + call $assembly/memory/MaybePageFault#set:isFault + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $newSbrk + i32.wrap_i64 + call $assembly/memory/Memory#set:sbrkAddress + local.get $newSbrk + i64.const 1 + i64.sub + global.get $assembly/memory-page/PAGE_SIZE_SHIFT + i64.extend_i32_u + i64.shr_s + i32.wrap_i64 + local.set $pageIdx + local.get $pageIdx + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.eq + if + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $7 + return + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory/Memory#get:lastAllocatedPage + i32.const 1 + i32.add + local.set $i + loop $for-loop|0 + local.get $i + local.get $pageIdx + i32.le_s + if + global.get $~lib/memory/__stack_pointer + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $assembly/memory/Memory#get:arena + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + call $assembly/memory-page/Arena#acquire + local.tee $page + i32.store offset=12 + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory/Memory#get:pages + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $i + i32.const 0 + global.get $assembly/memory-page/Access.Write + local.get $page + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=16 + local.get $7 + call $assembly/memory-page/Page#constructor + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=8 + local.get $7 + call $"~lib/map/Map#set" + drop + local.get $i + i32.const 1 + i32.add + local.set $i + br $for-loop|0 + end + end + local.get $this + local.set $7 + global.get $~lib/memory/__stack_pointer + local.get $7 + i32.store offset=4 + local.get $7 + local.get $pageIdx + call $assembly/memory/Memory#set:lastAllocatedPage + local.get $freeMemoryStart + local.set $7 + global.get $~lib/memory/__stack_pointer + i32.const 20 i32.add global.set $~lib/memory/__stack_pointer - local.get $3 + local.get $7 return ) (func $assembly/instructions/outcome/okOrFault (param $pageFault i32) (result i32) @@ -27559,6 +27787,211 @@ local.get $2 return ) + (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) + (local $res i32) + (local $4 i32) + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store offset=8 + global.get $~lib/memory/__stack_pointer + local.get $memory + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=8 + local.get $4 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + call $~lib/staticarray/StaticArray#__get + i32.wrap_i64 + call $assembly/memory/Memory#sbrk + local.tee $res + i32.store offset=12 + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/memory/MaybePageFault#get:isFault + if + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:fault + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + call $assembly/instructions/outcome/okOrFault + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + end + local.get $registers + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store + local.get $4 + local.get $args + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $res + local.set $4 + global.get $~lib/memory/__stack_pointer + local.get $4 + i32.store offset=4 + local.get $4 + call $assembly/memory/Result#get:ok + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $4 + global.get $~lib/memory/__stack_pointer + i32.const 16 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $4 + return + ) + (func $start:assembly/instructions/load~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + i64.extend_i32_u + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:c + i64.extend_i32_u + i64.const 32 + i64.shl + i64.add + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) + (func $start:assembly/instructions/load~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) + (local $3 i32) + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.sub + global.set $~lib/memory/__stack_pointer + call $~stack_check + global.get $~lib/memory/__stack_pointer + i64.const 0 + i64.store + local.get $registers + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store + local.get $3 + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:a + i64.extend_i32_u + call $assembly/instructions/utils/reg + local.get $args + local.set $3 + global.get $~lib/memory/__stack_pointer + local.get $3 + i32.store offset=4 + local.get $3 + call $assembly/arguments/Args#get:b + call $assembly/instructions/utils/u32SignExtend + call $~lib/staticarray/StaticArray#__set + call $assembly/instructions/outcome/ok + local.set $3 + global.get $~lib/memory/__stack_pointer + i32.const 8 + i32.add + global.set $~lib/memory/__stack_pointer + local.get $3 + return + ) (func $start:assembly/instructions/load~anonymous|2 (param $args i32) (param $registers i32) (param $memory i32) (result i32) (local $result i32) (local $4 i32) @@ -33275,437 +33708,6 @@ local.get $5 return ) - (func $assembly/instructions/outcome/status (param $result i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $result - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Result.HOST - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $id - call $assembly/instructions/outcome/OutcomeData#set:exitCode - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:a - call $assembly/instructions/outcome/hostCall - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) - (local $freeMemoryStart i32) - (local $newSbrk i64) - (local $pageIdx i32) - (local $i i32) - (local $page i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $freeMemoryStart - i32.store - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $amount - i32.const 0 - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - local.get $amount - i64.extend_i32_u - i64.add - local.set $newSbrk - local.get $newSbrk - global.get $assembly/memory/MEMORY_SIZE - i64.ge_s - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Result#get:fault - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isFault - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $newSbrk - i32.wrap_i64 - call $assembly/memory/Memory#set:sbrkAddress - local.get $newSbrk - i64.const 1 - i64.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - local.set $pageIdx - local.get $pageIdx - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.const 1 - i32.add - local.set $i - loop $for-loop|0 - local.get $i - local.get $pageIdx - i32.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:arena - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=12 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory/Memory#get:pages - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $i - i32.const 0 - global.get $assembly/memory-page/Access.Write - local.get $page - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory-page/Page#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $"~lib/map/Map#set" - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $pageIdx - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#sbrk - local.tee $res - i32.store offset=12 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) (func $~lib/array/Array#get:length (param $this i32) (result i32) (local $1 i32) global.get $~lib/memory/__stack_pointer @@ -39151,15 +39153,20 @@ call $~lib/staticarray/StaticArray#constructor local.tee $isStartOrEnd i32.store offset=8 - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 + local.get $len i32.const 0 - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set + i32.gt_s + if + local.get $isStartOrEnd + local.set $11 + global.get $~lib/memory/__stack_pointer + local.get $11 + i32.store offset=4 + local.get $11 + i32.const 0 + global.get $assembly/program/BasicBlock.START + call $~lib/staticarray/StaticArray#__set + end i32.const 0 local.set $n loop $for-loop|0 @@ -41541,7 +41548,7 @@ call $assembly/codec/Decoder#isExhausted i32.eqz if - i32.const 25696 + i32.const 25808 local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 @@ -41739,6 +41746,8 @@ ) (func $assembly/spi/decodeSpi (param $data i32) (param $args i32) (result i32) (local $argsLength i32) + (local $3 i32) + (local $4 i32) (local $decoder i32) (local $roLength i32) (local $rwLength i32) @@ -41758,30 +41767,82 @@ (local $stackStart i32) (local $memory i32) (local $registers i32) - (local $22 i32) + (local $24 i32) global.get $~lib/memory/__stack_pointer - i32.const 44 + i32.const 52 i32.sub global.set $~lib/memory/__stack_pointer call $~stack_check global.get $~lib/memory/__stack_pointer i32.const 0 - i32.const 44 + i32.const 52 memory.fill local.get $args - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 call $~lib/typedarray/Uint8Array#get:length local.set $argsLength local.get $argsLength - global.get $assembly/spi/DATA_LENGTH + global.get $assembly/spi/MAX_ARGS_LEN i32.gt_u if - i32.const 25552 - i32.const 25632 + global.get $~lib/memory/__stack_pointer + local.get $argsLength + i32.const 10 + call $~lib/number/U32#toString + local.tee $3 + i32.store offset=4 + global.get $~lib/memory/__stack_pointer + global.get $assembly/spi/MAX_ARGS_LEN + i32.const 10 + call $~lib/number/U32#toString + local.tee $4 + i32.store offset=8 + i32.const 25696 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 1 + local.get $3 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=12 + local.get $24 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 25696 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 3 + local.get $4 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=12 + local.get $24 + call $~lib/staticarray/StaticArray<~lib/string/String>#__uset + i32.const 25696 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store + local.get $24 + i32.const 4080 + local.set $24 + global.get $~lib/memory/__stack_pointer + local.get $24 + i32.store offset=12 + local.get $24 + call $~lib/staticarray/StaticArray<~lib/string/String>#join + i32.const 25744 i32.const 18 i32.const 5 call $~lib/builtins/abort @@ -41790,110 +41851,110 @@ global.get $~lib/memory/__stack_pointer i32.const 0 local.get $data - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 i32.const 0 call $assembly/codec/Decoder#constructor local.tee $decoder - i32.store offset=4 + i32.store offset=16 local.get $decoder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 call $assembly/codec/Decoder#u24 local.set $roLength local.get $decoder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 call $assembly/codec/Decoder#u24 local.set $rwLength local.get $decoder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 call $assembly/codec/Decoder#u16 local.set $heapPages local.get $decoder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 call $assembly/codec/Decoder#u24 local.set $stackSize global.get $~lib/memory/__stack_pointer local.get $decoder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 local.get $roLength call $assembly/codec/Decoder#bytes local.tee $roMem - i32.store offset=8 + i32.store offset=20 global.get $~lib/memory/__stack_pointer local.get $decoder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 local.get $rwLength call $assembly/codec/Decoder#bytes local.tee $rwMem - i32.store offset=12 + i32.store offset=24 local.get $decoder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 call $assembly/codec/Decoder#u32 local.set $codeLength global.get $~lib/memory/__stack_pointer local.get $decoder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 local.get $codeLength call $assembly/codec/Decoder#bytes local.tee $code - i32.store offset=16 + i32.store offset=28 local.get $decoder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 call $assembly/codec/Decoder#finish global.get $~lib/memory/__stack_pointer local.get $code - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 call $assembly/program/deblob local.tee $program - i32.store offset=20 + i32.store offset=32 global.get $~lib/memory/__stack_pointer i32.const 0 call $assembly/memory/MemoryBuilder#constructor local.tee $builder - i32.store offset=24 + i32.store offset=36 i32.const 2 global.get $assembly/memory-page/SEGMENT_SIZE i32.mul @@ -41928,19 +41989,19 @@ i32.gt_u if local.get $builder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 global.get $assembly/memory-page/Access.Read global.get $assembly/memory-page/SEGMENT_SIZE local.get $roMem - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store offset=28 - local.get $22 + local.get $24 + i32.store offset=12 + local.get $24 call $assembly/memory/MemoryBuilder#setData drop end @@ -41949,19 +42010,19 @@ i32.gt_u if local.get $builder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 global.get $assembly/memory-page/Access.Read global.get $assembly/spi/ARGS_SEGMENT_START local.get $args - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store offset=28 - local.get $22 + local.get $24 + i32.store offset=12 + local.get $24 call $assembly/memory/MemoryBuilder#setData drop end @@ -41970,19 +42031,19 @@ i32.gt_u if local.get $builder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 global.get $assembly/memory-page/Access.Write local.get $heapStart local.get $rwMem - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store offset=28 - local.get $22 + local.get $24 + i32.store offset=12 + local.get $24 call $assembly/memory/MemoryBuilder#setData drop end @@ -41991,11 +42052,11 @@ i32.gt_u if local.get $builder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 global.get $assembly/memory-page/Access.Write local.get $heapZerosStart local.get $heapZerosLength @@ -42007,11 +42068,11 @@ i32.gt_u if local.get $builder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 global.get $assembly/memory-page/Access.Write local.get $stackStart local.get $stackLength @@ -42020,86 +42081,86 @@ end global.get $~lib/memory/__stack_pointer local.get $builder - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 local.get $heapZerosEnd call $assembly/memory/MemoryBuilder#build local.tee $memory - i32.store offset=32 + i32.store offset=40 global.get $~lib/memory/__stack_pointer i32.const 0 global.get $assembly/registers/NO_OF_REGISTERS call $~lib/staticarray/StaticArray#constructor local.tee $registers - i32.store offset=36 + i32.store offset=44 local.get $registers - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 i32.const 0 i64.const 4294901760 call $~lib/staticarray/StaticArray#__set local.get $registers - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 i32.const 1 global.get $assembly/spi/STACK_SEGMENT_END i64.extend_i32_u call $~lib/staticarray/StaticArray#__set local.get $registers - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 i32.const 7 global.get $assembly/spi/ARGS_SEGMENT_START i64.extend_i32_u call $~lib/staticarray/StaticArray#__set local.get $registers - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 i32.const 8 local.get $argsLength i64.extend_i32_u call $~lib/staticarray/StaticArray#__set i32.const 0 local.get $program - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 + local.get $24 i32.store - local.get $22 + local.get $24 local.get $memory - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store offset=28 - local.get $22 + local.get $24 + i32.store offset=12 + local.get $24 local.get $registers - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store offset=40 - local.get $22 + local.get $24 + i32.store offset=48 + local.get $24 call $assembly/spi/StandardProgram#constructor - local.set $22 + local.set $24 global.get $~lib/memory/__stack_pointer - i32.const 44 + i32.const 52 i32.add global.set $~lib/memory/__stack_pointer - local.get $22 + local.get $24 return ) (func $assembly/program/Program#toString (param $this i32) (result i32) @@ -42181,7 +42242,7 @@ call $assembly/program/BasicBlocks#toString local.tee $4 i32.store offset=20 - i32.const 26320 + i32.const 26432 local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 @@ -42195,7 +42256,7 @@ i32.store offset=4 local.get $5 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26320 + i32.const 26432 local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 @@ -42209,7 +42270,7 @@ i32.store offset=4 local.get $5 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26320 + i32.const 26432 local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 @@ -42223,7 +42284,7 @@ i32.store offset=4 local.get $5 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26320 + i32.const 26432 local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 @@ -42237,7 +42298,7 @@ i32.store offset=4 local.get $5 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26320 + i32.const 26432 local.set $5 global.get $~lib/memory/__stack_pointer local.get $5 @@ -42600,7 +42661,7 @@ call $~lib/staticarray/StaticArray#toString local.tee $3 i32.store offset=20 - i32.const 26048 + i32.const 26160 local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 @@ -42614,7 +42675,7 @@ i32.store offset=4 local.get $4 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26048 + i32.const 26160 local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 @@ -42628,7 +42689,7 @@ i32.store offset=4 local.get $4 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26048 + i32.const 26160 local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 @@ -42642,7 +42703,7 @@ i32.store offset=4 local.get $4 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26048 + i32.const 26160 local.set $4 global.get $~lib/memory/__stack_pointer local.get $4 @@ -42747,7 +42808,7 @@ local.get $7 i32.store offset=12 local.get $7 - i32.const 26384 + i32.const 26496 local.set $7 global.get $~lib/memory/__stack_pointer local.get $7 @@ -42800,7 +42861,7 @@ local.get $1 i32.store offset=4 local.get $1 - i32.const 26864 + i32.const 26976 local.set $1 global.get $~lib/memory/__stack_pointer local.get $1 @@ -43020,9 +43081,9 @@ local.get $total i32.eq if (result i32) - i32.const 27216 + i32.const 27328 else - i32.const 27248 + i32.const 27360 end local.tee $ico i32.store @@ -43046,7 +43107,7 @@ local.get $ico local.tee $7 i32.store offset=20 - i32.const 27344 + i32.const 27456 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43060,7 +43121,7 @@ i32.store offset=28 local.get $8 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27344 + i32.const 27456 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43074,7 +43135,7 @@ i32.store offset=28 local.get $8 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27344 + i32.const 27456 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43088,7 +43149,7 @@ i32.store offset=28 local.get $8 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27344 + i32.const 27456 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43102,7 +43163,7 @@ i32.store offset=28 local.get $8 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27344 + i32.const 27456 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43146,7 +43207,7 @@ memory.fill i32.const 0 local.set $ok - i32.const 26928 + i32.const 27040 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43178,7 +43239,7 @@ call $~lib/array/Array#get:length i32.lt_s if - i32.const 26960 + i32.const 27072 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43263,7 +43324,7 @@ call $assembly/test/Test#get:name local.tee $5 i32.store offset=24 - i32.const 27056 + i32.const 27168 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43277,7 +43338,7 @@ i32.store offset=8 local.get $8 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27056 + i32.const 27168 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43320,7 +43381,7 @@ call $~lib/array/Array<~lib/string/String>#get:length i32.lt_s if - i32.const 27088 + i32.const 27200 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43376,7 +43437,7 @@ call $assembly/test/Test#get:name local.tee $7 i32.store offset=28 - i32.const 27152 + i32.const 27264 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43390,7 +43451,7 @@ i32.store offset=8 local.get $8 call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27152 + i32.const 27264 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43417,7 +43478,7 @@ br $for-loop|0 end end - i32.const 27184 + i32.const 27296 local.set $8 global.get $~lib/memory/__stack_pointer local.get $8 @@ -43487,7 +43548,7 @@ local.get $3 i32.store local.get $3 - i32.const 26896 + i32.const 27008 local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -43503,7 +43564,7 @@ local.get $3 i32.store local.get $3 - i32.const 27392 + i32.const 27504 local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -43519,7 +43580,7 @@ local.get $3 i32.store local.get $3 - i32.const 27440 + i32.const 27552 local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -43535,7 +43596,7 @@ local.get $3 i32.store local.get $3 - i32.const 27488 + i32.const 27600 local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -43551,7 +43612,7 @@ local.get $3 i32.store local.get $3 - i32.const 27536 + i32.const 27648 local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -43567,7 +43628,7 @@ local.get $3 i32.store local.get $3 - i32.const 27584 + i32.const 27696 local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -43583,7 +43644,7 @@ local.get $3 i32.store local.get $3 - i32.const 27632 + i32.const 27744 local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -43599,7 +43660,7 @@ local.get $3 i32.store local.get $3 - i32.const 27664 + i32.const 27776 local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -43616,7 +43677,7 @@ local.get $a i32.wrap_i64 local.set $total - i32.const 27696 + i32.const 27808 local.set $3 global.get $~lib/memory/__stack_pointer local.get $3 @@ -43629,8 +43690,8 @@ local.get $total i32.ne if - i32.const 27744 - i32.const 27808 + i32.const 27856 + i32.const 27920 i32.const 28 i32.const 5 call $~lib/builtins/abort From 4f6d7feb8874d6282d01a741bcc0850050131812 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Thu, 16 Oct 2025 13:30:12 +0200 Subject: [PATCH 10/21] deleted unused api --- assembly/api-debugger.ts | 22 +++------------------- assembly/interpreter.ts | 6 ++++-- build/.gitignore | 1 + 3 files changed, 8 insertions(+), 21 deletions(-) diff --git a/assembly/api-debugger.ts b/assembly/api-debugger.ts index dc2d153..c85a96e 100644 --- a/assembly/api-debugger.ts +++ b/assembly/api-debugger.ts @@ -111,12 +111,12 @@ export function getStatus(): u8 { return int.status; } -export function getExitArg(): i32 { +export function getExitArg(): u32 { if (interpreter === null) { - return -1; + return 0; } const int = interpreter; - return int.exitCode || -1; + return int.exitCode || 0; } export function getGasLeft(): i64 { @@ -134,22 +134,6 @@ export function setGasLeft(gas: i64): void { } } -export function getRegister(reg: u8): u64 { - if (interpreter === null) { - return 0; - } - const int = interpreter; - return int.registers[reg]; -} - -export function setRegister(reg: u8, value: u64): void { - if (interpreter === null) { - return; - } - const int = interpreter; - int.registers[reg] = value; -} - export function getRegisters(): Uint8Array { const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0); if (interpreter === null) { diff --git a/assembly/interpreter.ts b/assembly/interpreter.ts index c92e839..707c764 100644 --- a/assembly/interpreter.ts +++ b/assembly/interpreter.ts @@ -36,7 +36,7 @@ export class Interpreter { this.gas = gasCounter(0); this.pc = 0; this.status = Status.OK; - this.exitCode = -1; + this.exitCode = 0; this.nextPc = 0; this.useSbrkGas = false; } @@ -50,7 +50,6 @@ export class Interpreter { // executing right away. this.pc = this.nextPc; this.nextPc = -1; - this.exitCode = -1; } if (this.status !== Status.OK) { @@ -64,6 +63,9 @@ export class Interpreter { return true; } + // reset some stuff at start + this.exitCode = 0; + const pc = this.pc; // check if we are at the right location if (!this.program.mask.isInstruction(pc)) { diff --git a/build/.gitignore b/build/.gitignore index f935021..d6b7ef3 100644 --- a/build/.gitignore +++ b/build/.gitignore @@ -1 +1,2 @@ +* !.gitignore From 71bbf0139d10348ac93c62adf663f0d23e63fa35 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Thu, 16 Oct 2025 13:32:32 +0200 Subject: [PATCH 11/21] deleted build files --- build/debug.d.ts | 223 - build/debug.js | 417 - build/debug.wasm | Bin 199232 -> 0 bytes build/debug.wasm.map | 1 - build/debug.wat | 48277 --------------------------------------- build/release.d.ts | 223 - build/release.js | 417 - build/release.wasm | Bin 97855 -> 0 bytes build/release.wasm.map | 1 - build/release.wat | 38657 ------------------------------- build/test.d.ts | 6 - build/test.js | 47 - build/test.wasm | Bin 189870 -> 0 bytes build/test.wasm.map | 1 - build/test.wat | 45430 ------------------------------------ 15 files changed, 133700 deletions(-) delete mode 100644 build/debug.d.ts delete mode 100644 build/debug.js delete mode 100644 build/debug.wasm delete mode 100644 build/debug.wasm.map delete mode 100644 build/debug.wat delete mode 100644 build/release.d.ts delete mode 100644 build/release.js delete mode 100644 build/release.wasm delete mode 100644 build/release.wasm.map delete mode 100644 build/release.wat delete mode 100644 build/test.d.ts delete mode 100644 build/test.js delete mode 100644 build/test.wasm delete mode 100644 build/test.wasm.map delete mode 100644 build/test.wat diff --git a/build/debug.d.ts b/build/debug.d.ts deleted file mode 100644 index bfa811d..0000000 --- a/build/debug.d.ts +++ /dev/null @@ -1,223 +0,0 @@ -/** Exported memory */ -export declare const memory: WebAssembly.Memory; -/** - * assembly/api-internal/getAssembly - * @param p `assembly/program/Program` - * @returns `~lib/string/String` - */ -export declare function getAssembly(p: __Internref30): string; -/** - * assembly/program-build/wrapAsProgram - * @param bytecode `~lib/typedarray/Uint8Array` - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array; -/** - * assembly/api-debugger/resetJAM - * @param program `~lib/array/Array` - * @param pc `f64` - * @param initialGas `i64` - * @param args `~lib/array/Array` - * @param hasMetadata `bool` - */ -export declare function resetJAM(program: Array, pc: number, initialGas: bigint, args: Array, hasMetadata?: boolean): void; -/** - * assembly/api-debugger/resetGeneric - * @param program `~lib/array/Array` - * @param flatRegisters `~lib/array/Array` - * @param initialGas `i64` - * @param hasMetadata `bool` - */ -export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint, hasMetadata?: boolean): void; -/** - * assembly/api-debugger/resetGenericWithMemory - * @param program `~lib/array/Array` - * @param flatRegisters `~lib/array/Array` - * @param pageMap `~lib/typedarray/Uint8Array` - * @param chunks `~lib/typedarray/Uint8Array` - * @param initialGas `i64` - * @param hasMetadata `bool` - */ -export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint, hasMetadata?: boolean): void; -/** - * assembly/api-debugger/nextStep - * @returns `bool` - */ -export declare function nextStep(): boolean; -/** - * assembly/api-debugger/nSteps - * @param steps `u32` - * @returns `bool` - */ -export declare function nSteps(steps: number): boolean; -/** - * assembly/api-debugger/getProgramCounter - * @returns `u32` - */ -export declare function getProgramCounter(): number; -/** - * assembly/api-debugger/setNextProgramCounter - * @param pc `u32` - */ -export declare function setNextProgramCounter(pc: number): void; -/** - * assembly/api-debugger/getStatus - * @returns `u8` - */ -export declare function getStatus(): number; -/** - * assembly/api-debugger/getExitArg - * @returns `i32` - */ -export declare function getExitArg(): number; -/** - * assembly/api-debugger/getGasLeft - * @returns `i64` - */ -export declare function getGasLeft(): bigint; -/** - * assembly/api-debugger/setGasLeft - * @param gas `i64` - */ -export declare function setGasLeft(gas: bigint): void; -/** - * assembly/api-debugger/getRegister - * @param reg `u8` - * @returns `u64` - */ -export declare function getRegister(reg: number): bigint; -/** - * assembly/api-debugger/setRegister - * @param reg `u8` - * @param value `u64` - */ -export declare function setRegister(reg: number, value: bigint): void; -/** - * assembly/api-debugger/getRegisters - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function getRegisters(): Uint8Array; -/** - * assembly/api-debugger/setRegisters - * @param flatRegisters `~lib/array/Array` - */ -export declare function setRegisters(flatRegisters: Array): void; -/** - * assembly/api-debugger/getPageDump - * @param index `u32` - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function getPageDump(index: number): Uint8Array; -/** - * assembly/api-debugger/getMemory - * @param address `u32` - * @param length `u32` - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function getMemory(address: number, length: number): Uint8Array; -/** - * assembly/api-debugger/setMemory - * @param address `u32` - * @param data `~lib/typedarray/Uint8Array` - */ -export declare function setMemory(address: number, data: Uint8Array): void; -/** assembly/api-utils/InputKind */ -export declare enum InputKind { - /** @type `i32` */ - Generic, - /** @type `i32` */ - SPI, -} -/** assembly/api-utils/HasMetadata */ -export declare enum HasMetadata { - /** @type `i32` */ - Yes, - /** @type `i32` */ - No, -} -/** - * assembly/api-utils/getGasCosts - * @param input `~lib/array/Array` - * @param kind `i32` - * @param withMetadata `i32` - * @returns `~lib/array/Array` - */ -export declare function getGasCosts(input: Array, kind: number, withMetadata: number): Array<__Record54>; -/** - * assembly/api-utils/disassemble - * @param input `~lib/array/Array` - * @param kind `i32` - * @param withMetadata `i32` - * @returns `~lib/string/String` - */ -export declare function disassemble(input: Array, kind: number, withMetadata: number): string; -/** - * assembly/api-utils/prepareProgram - * @param kind `i32` - * @param hasMetadata `i32` - * @param program `~lib/array/Array` - * @param initialRegisters `~lib/array/Array` - * @param initialPageMap `~lib/array/Array` - * @param initialMemory `~lib/array/Array` - * @param args `~lib/array/Array` - * @returns `assembly/spi/StandardProgram` - */ -export declare function prepareProgram(kind: number, hasMetadata: number, program: Array, initialRegisters: Array, initialPageMap: Array<__Record48>, initialMemory: Array<__Record50>, args: Array): __Internref44; -/** - * assembly/api-utils/runProgram - * @param program `assembly/spi/StandardProgram` - * @param initialGas `i64` - * @param programCounter `u32` - * @param logs `bool` - * @param useSbrkGas `bool` - * @returns `assembly/api-internal/VmOutput` - */ -export declare function runProgram(program: __Internref44, initialGas?: bigint, programCounter?: number, logs?: boolean, useSbrkGas?: boolean): __Record59; -/** assembly/program/Program */ -declare class __Internref30 extends Number { - private __nominal30: symbol; - private __nominal0: symbol; -} -/** assembly/gas-costs/BlockGasCost */ -declare interface __Record54 { - /** @type `u32` */ - pc: number | TOmittable; - /** @type `u64` */ - gas: bigint | TOmittable; -} -/** assembly/api-internal/InitialPage */ -declare interface __Record48 { - /** @type `u32` */ - address: number | TOmittable; - /** @type `u32` */ - length: number | TOmittable; - /** @type `i32` */ - access: number | TOmittable; -} -/** assembly/api-internal/InitialChunk */ -declare interface __Record50 { - /** @type `u32` */ - address: number | TOmittable; - /** @type `~lib/array/Array` */ - data: Array; -} -/** assembly/spi/StandardProgram */ -declare class __Internref44 extends Number { - private __nominal44: symbol; - private __nominal0: symbol; -} -/** assembly/api-internal/VmOutput */ -declare interface __Record59 { - /** @type `i32` */ - status: number | TOmittable; - /** @type `~lib/array/Array` */ - registers: Array; - /** @type `u32` */ - pc: number | TOmittable; - /** @type `~lib/array/Array` */ - memory: Array<__Record50>; - /** @type `i64` */ - gas: bigint | TOmittable; - /** @type `u32` */ - exitCode: number | TOmittable; -} diff --git a/build/debug.js b/build/debug.js deleted file mode 100644 index bc5137a..0000000 --- a/build/debug.js +++ /dev/null @@ -1,417 +0,0 @@ -async function instantiate(module, imports = {}) { - const adaptedImports = { - env: Object.setPrototypeOf({ - abort(message, fileName, lineNumber, columnNumber) { - // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void - message = __liftString(message >>> 0); - fileName = __liftString(fileName >>> 0); - lineNumber = lineNumber >>> 0; - columnNumber = columnNumber >>> 0; - (() => { - // @external.js - throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); - })(); - }, - "console.log"(text) { - // ~lib/bindings/dom/console.log(~lib/string/String) => void - text = __liftString(text >>> 0); - console.log(text); - }, - }, Object.assign(Object.create(globalThis), imports.env || {})), - }; - const { exports } = await WebAssembly.instantiate(module, adaptedImports); - const memory = exports.memory || imports.env.memory; - const adaptedExports = Object.setPrototypeOf({ - getAssembly(p) { - // assembly/api-internal/getAssembly(assembly/program/Program) => ~lib/string/String - p = __lowerInternref(p) || __notnull(); - return __liftString(exports.getAssembly(p) >>> 0); - }, - wrapAsProgram(bytecode) { - // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array - bytecode = __lowerTypedArray(Uint8Array, 5, 0, bytecode) || __notnull(); - return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0); - }, - resetJAM(program, pc, initialGas, args, hasMetadata) { - // assembly/api-debugger/resetJAM(~lib/array/Array, f64, i64, ~lib/array/Array, bool?) => void - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - initialGas = initialGas || 0n; - args = __lowerArray(__setU8, 27, 0, args) || __notnull(); - hasMetadata = hasMetadata ? 1 : 0; - try { - exports.__setArgumentsLength(arguments.length); - exports.resetJAM(program, pc, initialGas, args, hasMetadata); - } finally { - __release(program); - } - }, - resetGeneric(program, flatRegisters, initialGas, hasMetadata) { - // assembly/api-debugger/resetGeneric(~lib/array/Array, ~lib/array/Array, i64, bool?) => void - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); - initialGas = initialGas || 0n; - hasMetadata = hasMetadata ? 1 : 0; - try { - exports.__setArgumentsLength(arguments.length); - exports.resetGeneric(program, flatRegisters, initialGas, hasMetadata); - } finally { - __release(program); - } - }, - resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata) { - // assembly/api-debugger/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64, bool?) => void - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - flatRegisters = __retain(__lowerArray(__setU8, 27, 0, flatRegisters) || __notnull()); - pageMap = __retain(__lowerTypedArray(Uint8Array, 5, 0, pageMap) || __notnull()); - chunks = __lowerTypedArray(Uint8Array, 5, 0, chunks) || __notnull(); - initialGas = initialGas || 0n; - hasMetadata = hasMetadata ? 1 : 0; - try { - exports.__setArgumentsLength(arguments.length); - exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata); - } finally { - __release(program); - __release(flatRegisters); - __release(pageMap); - } - }, - nextStep() { - // assembly/api-debugger/nextStep() => bool - return exports.nextStep() != 0; - }, - nSteps(steps) { - // assembly/api-debugger/nSteps(u32) => bool - return exports.nSteps(steps) != 0; - }, - getProgramCounter() { - // assembly/api-debugger/getProgramCounter() => u32 - return exports.getProgramCounter() >>> 0; - }, - setGasLeft(gas) { - // assembly/api-debugger/setGasLeft(i64) => void - gas = gas || 0n; - exports.setGasLeft(gas); - }, - getRegister(reg) { - // assembly/api-debugger/getRegister(u8) => u64 - return BigInt.asUintN(64, exports.getRegister(reg)); - }, - setRegister(reg, value) { - // assembly/api-debugger/setRegister(u8, u64) => void - value = value || 0n; - exports.setRegister(reg, value); - }, - getRegisters() { - // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array - return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); - }, - setRegisters(flatRegisters) { - // assembly/api-debugger/setRegisters(~lib/array/Array) => void - flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); - exports.setRegisters(flatRegisters); - }, - getPageDump(index) { - // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array - return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); - }, - getMemory(address, length) { - // assembly/api-debugger/getMemory(u32, u32) => ~lib/typedarray/Uint8Array - return __liftTypedArray(Uint8Array, exports.getMemory(address, length) >>> 0); - }, - setMemory(address, data) { - // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void - data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); - exports.setMemory(address, data); - }, - InputKind: (values => ( - // assembly/api-utils/InputKind - values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", - values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", - values - ))({}), - HasMetadata: (values => ( - // assembly/api-utils/HasMetadata - values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", - values[values.No = exports["HasMetadata.No"].valueOf()] = "No", - values - ))({}), - getGasCosts(input, kind, withMetadata) { - // assembly/api-utils/getGasCosts(~lib/array/Array, i32, i32) => ~lib/array/Array - input = __lowerArray(__setU8, 27, 0, input) || __notnull(); - return __liftArray(pointer => __liftRecord54(__getU32(pointer)), 2, exports.getGasCosts(input, kind, withMetadata) >>> 0); - }, - disassemble(input, kind, withMetadata) { - // assembly/api-utils/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String - input = __lowerArray(__setU8, 27, 0, input) || __notnull(); - return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); - }, - prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) { - // assembly/api-utils/prepareProgram(i32, i32, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array) => assembly/spi/StandardProgram - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - initialRegisters = __retain(__lowerArray(__setU64, 56, 3, initialRegisters) || __notnull()); - initialPageMap = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, initialPageMap) || __notnull()); - initialMemory = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord50(value) || __notnull()); }, 51, 2, initialMemory) || __notnull()); - args = __lowerArray(__setU8, 27, 0, args) || __notnull(); - try { - return __liftInternref(exports.prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) >>> 0); - } finally { - __release(program); - __release(initialRegisters); - __release(initialPageMap); - __release(initialMemory); - } - }, - runProgram(program, initialGas, programCounter, logs, useSbrkGas) { - // assembly/api-utils/runProgram(assembly/spi/StandardProgram, i64?, u32?, bool?, bool?) => assembly/api-internal/VmOutput - program = __lowerInternref(program) || __notnull(); - initialGas = initialGas || 0n; - logs = logs ? 1 : 0; - useSbrkGas = useSbrkGas ? 1 : 0; - exports.__setArgumentsLength(arguments.length); - return __liftRecord59(exports.runProgram(program, initialGas, programCounter, logs, useSbrkGas) >>> 0); - }, - }, exports); - function __liftRecord54(pointer) { - // assembly/gas-costs/BlockGasCost - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - pc: __getU32(pointer + 0), - gas: __getU64(pointer + 8), - }; - } - function __lowerRecord48(value) { - // assembly/api-internal/InitialPage - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(12, 48)); - __setU32(pointer + 0, value.address); - __setU32(pointer + 4, value.length); - __setU32(pointer + 8, value.access); - exports.__unpin(pointer); - return pointer; - } - function __lowerRecord50(value) { - // assembly/api-internal/InitialChunk - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(8, 50)); - __setU32(pointer + 0, value.address); - __setU32(pointer + 4, __lowerArray(__setU8, 27, 0, value.data) || __notnull()); - exports.__unpin(pointer); - return pointer; - } - function __liftRecord50(pointer) { - // assembly/api-internal/InitialChunk - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - address: __getU32(pointer + 0), - data: __liftArray(__getU8, 0, __getU32(pointer + 4)), - }; - } - function __liftRecord59(pointer) { - // assembly/api-internal/VmOutput - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - status: __getI32(pointer + 0), - registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), - pc: __getU32(pointer + 8), - memory: __liftArray(pointer => __liftRecord50(__getU32(pointer)), 2, __getU32(pointer + 12)), - gas: __getI64(pointer + 16), - exitCode: __getU32(pointer + 24), - }; - } - function __liftString(pointer) { - if (!pointer) return null; - const - end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, - memoryU16 = new Uint16Array(memory.buffer); - let - start = pointer >>> 1, - string = ""; - while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); - return string + String.fromCharCode(...memoryU16.subarray(start, end)); - } - function __liftArray(liftElement, align, pointer) { - if (!pointer) return null; - const - dataStart = __getU32(pointer + 4), - length = __dataview.getUint32(pointer + 12, true), - values = new Array(length); - for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0)); - return values; - } - function __lowerArray(lowerElement, id, align, values) { - if (values == null) return 0; - const - length = values.length, - buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, - header = exports.__pin(exports.__new(16, id)) >>> 0; - __setU32(header + 0, buffer); - __dataview.setUint32(header + 4, buffer, true); - __dataview.setUint32(header + 8, length << align, true); - __dataview.setUint32(header + 12, length, true); - for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]); - exports.__unpin(buffer); - exports.__unpin(header); - return header; - } - function __liftTypedArray(constructor, pointer) { - if (!pointer) return null; - return new constructor( - memory.buffer, - __getU32(pointer + 4), - __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT - ).slice(); - } - function __lowerTypedArray(constructor, id, align, values) { - if (values == null) return 0; - const - length = values.length, - buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, - header = exports.__new(12, id) >>> 0; - __setU32(header + 0, buffer); - __dataview.setUint32(header + 4, buffer, true); - __dataview.setUint32(header + 8, length << align, true); - new constructor(memory.buffer, buffer, length).set(values); - exports.__unpin(buffer); - return header; - } - class Internref extends Number {} - const registry = new FinalizationRegistry(__release); - function __liftInternref(pointer) { - if (!pointer) return null; - const sentinel = new Internref(__retain(pointer)); - registry.register(sentinel, pointer); - return sentinel; - } - function __lowerInternref(value) { - if (value == null) return 0; - if (value instanceof Internref) return value.valueOf(); - throw TypeError("internref expected"); - } - const refcounts = new Map(); - function __retain(pointer) { - if (pointer) { - const refcount = refcounts.get(pointer); - if (refcount) refcounts.set(pointer, refcount + 1); - else refcounts.set(exports.__pin(pointer), 1); - } - return pointer; - } - function __release(pointer) { - if (pointer) { - const refcount = refcounts.get(pointer); - if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer); - else if (refcount) refcounts.set(pointer, refcount - 1); - else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`); - } - } - function __notnull() { - throw TypeError("value must not be null"); - } - let __dataview = new DataView(memory.buffer); - function __setU8(pointer, value) { - try { - __dataview.setUint8(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setUint8(pointer, value, true); - } - } - function __setU32(pointer, value) { - try { - __dataview.setUint32(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setUint32(pointer, value, true); - } - } - function __setU64(pointer, value) { - try { - __dataview.setBigUint64(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setBigUint64(pointer, value, true); - } - } - function __getU8(pointer) { - try { - return __dataview.getUint8(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getUint8(pointer, true); - } - } - function __getI32(pointer) { - try { - return __dataview.getInt32(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getInt32(pointer, true); - } - } - function __getU32(pointer) { - try { - return __dataview.getUint32(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getUint32(pointer, true); - } - } - function __getI64(pointer) { - try { - return __dataview.getBigInt64(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getBigInt64(pointer, true); - } - } - function __getU64(pointer) { - try { - return __dataview.getBigUint64(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getBigUint64(pointer, true); - } - } - return adaptedExports; -} -export const { - memory, - getAssembly, - wrapAsProgram, - resetJAM, - resetGeneric, - resetGenericWithMemory, - nextStep, - nSteps, - getProgramCounter, - setNextProgramCounter, - getStatus, - getExitArg, - getGasLeft, - setGasLeft, - getRegister, - setRegister, - getRegisters, - setRegisters, - getPageDump, - getMemory, - setMemory, - InputKind, - HasMetadata, - getGasCosts, - disassemble, - prepareProgram, - runProgram, -} = await (async url => instantiate( - await (async () => { - const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); - if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } - else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } - })(), { - } -))(new URL("debug.wasm", import.meta.url)); diff --git a/build/debug.wasm b/build/debug.wasm deleted file mode 100644 index 07934d4717b52f6df52d67d21d10e5e22cab607a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 199232 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

}_%k1aAK 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 diff --git a/build/debug.wasm.map b/build/debug.wasm.map deleted file mode 100644 index 06da30a..0000000 --- a/build/debug.wasm.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = -1;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n this.exitCode = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): i32 {\n if (interpreter === null) {\n return -1;\n }\n const int = interpreter;\n return int.exitCode || -1;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n if (logs) console.log(`Exit code: ${int.exitCode}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/debug.wat b/build/debug.wat deleted file mode 100644 index 35d2a41..0000000 --- a/build/debug.wat +++ /dev/null @@ -1,48277 +0,0 @@ -(module - (type $0 (func (param i32) (result i32))) - (type $1 (func (param i32 i32))) - (type $2 (func (param i32 i32 i32) (result i32))) - (type $3 (func (param i32 i32) (result i32))) - (type $4 (func (param i32 i32 i32))) - (type $5 (func (param i32 i32 i32 i32) (result i32))) - (type $6 (func (param i32))) - (type $7 (func (param i32) (result i64))) - (type $8 (func)) - (type $9 (func (param i32 i64))) - (type $10 (func (result i32))) - (type $11 (func (param i64 i64) (result i64))) - (type $12 (func (param i64 i32) (result i32))) - (type $13 (func (param i32 i64) (result i32))) - (type $14 (func (param i64) (result i32))) - (type $15 (func (param i32 i32 i64 i32))) - (type $16 (func (param i32 i32 i32 i32))) - (type $17 (func (param i32 f64 i64 i32 i32))) - (type $18 (func (param i32 i32 i32 i32 i64 i32))) - (type $19 (func (param i64 i32 i32) (result i32))) - (type $20 (func (param i32 i64 i32 i32 i32) (result i32))) - (type $21 (func (param i32 i32 i64) (result i32))) - (type $22 (func (param i32 i32 i64))) - (type $23 (func (param i32 i64 i32))) - (type $24 (func (param i32 i32) (result i64))) - (type $25 (func (param i32 i32 i32 i32 i32 i32 i32) (result i32))) - (type $26 (func (param i32 i32 i64 i32) (result i32))) - (type $27 (func (param i64) (result i64))) - (type $28 (func (param i32 i32 i32 i32 i32))) - (type $29 (func (param i32 i64 i32 i32))) - (type $30 (func (param i32 i32 i32 i32 i32) (result i32))) - (type $31 (func (result i64))) - (type $32 (func (param i64))) - (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) - (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) - (global $assembly/arguments/Arguments.Zero i32 (i32.const 0)) - (global $assembly/arguments/Arguments.OneImm i32 (i32.const 1)) - (global $assembly/arguments/Arguments.TwoImm i32 (i32.const 2)) - (global $assembly/arguments/Arguments.OneOff i32 (i32.const 3)) - (global $assembly/arguments/Arguments.OneRegOneImm i32 (i32.const 4)) - (global $assembly/arguments/Arguments.OneRegOneExtImm i32 (i32.const 5)) - (global $assembly/arguments/Arguments.OneRegTwoImm i32 (i32.const 6)) - (global $assembly/arguments/Arguments.OneRegOneImmOneOff i32 (i32.const 7)) - (global $assembly/arguments/Arguments.TwoReg i32 (i32.const 8)) - (global $assembly/arguments/Arguments.TwoRegOneImm i32 (i32.const 9)) - (global $assembly/arguments/Arguments.TwoRegOneOff i32 (i32.const 10)) - (global $assembly/arguments/Arguments.TwoRegTwoImm i32 (i32.const 11)) - (global $assembly/arguments/Arguments.ThreeReg i32 (i32.const 12)) - (global $assembly/arguments/RELEVANT_ARGS i32 (i32.const 112)) - (global $assembly/arguments/REQUIRED_BYTES i32 (i32.const 240)) - (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) - (global $~lib/shared/runtime/Runtime.Stub i32 (i32.const 0)) - (global $~lib/shared/runtime/Runtime.Minimal i32 (i32.const 1)) - (global $~lib/shared/runtime/Runtime.Incremental i32 (i32.const 2)) - (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) - (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) - (global $~lib/native/ASC_LOW_MEMORY_LIMIT i32 (i32.const 0)) - (global $~lib/builtins/i32.MAX_VALUE i32 (i32.const 2147483647)) - (global $~argumentsLength (mut i32) (i32.const 0)) - (global $assembly/arguments/DECODERS i32 (i32.const 1248)) - (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) - (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) - (global $~lib/native/ASC_RUNTIME i32 (i32.const 2)) - (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) - (global $assembly/registers/NO_OF_REGISTERS i32 (i32.const 13)) - (global $assembly/registers/REG_SIZE_BYTES i32 (i32.const 8)) - (global $~lib/native/ASC_SHRINK_LEVEL i32 (i32.const 0)) - (global $assembly/memory-page/PAGE_SIZE (mut i32) (i32.const 0)) - (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) - (global $assembly/memory-page/SEGMENT_SIZE (mut i32) (i32.const 0)) - (global $assembly/memory-page/SEGMENT_SIZE_SHIFT i32 (i32.const 16)) - (global $assembly/memory-page/RESERVED_MEMORY (mut i32) (i32.const 0)) - (global $assembly/memory-page/RESERVED_PAGES (mut i32) (i32.const 0)) - (global $assembly/memory-page/ALLOCATE_EAGERLY (mut i32) (i32.const 0)) - (global $assembly/memory-page/Access.None i32 (i32.const 0)) - (global $assembly/memory-page/Access.Read i32 (i32.const 1)) - (global $assembly/memory-page/Access.Write i32 (i32.const 2)) - (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) - (global $assembly/memory/MEMORY_SIZE i64 (i64.const 4294967296)) - (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) - (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) - (global $assembly/instructions/outcome/Result.PANIC i32 (i32.const 0)) - (global $assembly/instructions/outcome/Result.FAULT i32 (i32.const 1)) - (global $assembly/instructions/outcome/Result.FAULT_ACCESS i32 (i32.const 2)) - (global $assembly/instructions/outcome/Result.HOST i32 (i32.const 3)) - (global $assembly/instructions/outcome/Outcome.Ok i32 (i32.const 0)) - (global $assembly/instructions/outcome/Outcome.StaticJump i32 (i32.const 1)) - (global $assembly/instructions/outcome/Outcome.DynamicJump i32 (i32.const 2)) - (global $assembly/instructions/outcome/Outcome.Result i32 (i32.const 3)) - (global $assembly/instructions/bit/count_set_bits_64 i32 (i32.const 8352)) - (global $assembly/instructions/bit/count_set_bits_32 i32 (i32.const 8384)) - (global $assembly/instructions/bit/leading_zero_bits_64 i32 (i32.const 8416)) - (global $assembly/instructions/bit/leading_zero_bits_32 i32 (i32.const 8448)) - (global $assembly/instructions/bit/trailing_zero_bits_64 i32 (i32.const 8480)) - (global $assembly/instructions/bit/trailing_zero_bits_32 i32 (i32.const 8512)) - (global $assembly/instructions/bit/sign_extend_8 i32 (i32.const 8544)) - (global $assembly/instructions/bit/sign_extend_16 i32 (i32.const 8576)) - (global $assembly/instructions/bit/zero_extend_16 i32 (i32.const 8608)) - (global $assembly/instructions/bit/reverse_bytes i32 (i32.const 8640)) - (global $assembly/instructions/branch/branch_eq_imm i32 (i32.const 8672)) - (global $assembly/instructions/branch/branch_ne_imm i32 (i32.const 8704)) - (global $assembly/instructions/branch/branch_lt_u_imm i32 (i32.const 8736)) - (global $assembly/instructions/branch/branch_le_u_imm i32 (i32.const 8768)) - (global $assembly/instructions/branch/branch_ge_u_imm i32 (i32.const 8800)) - (global $assembly/instructions/branch/branch_gt_u_imm i32 (i32.const 8832)) - (global $assembly/instructions/branch/branch_lt_s_imm i32 (i32.const 8864)) - (global $assembly/instructions/branch/branch_le_s_imm i32 (i32.const 8896)) - (global $assembly/instructions/branch/branch_ge_s_imm i32 (i32.const 8928)) - (global $assembly/instructions/branch/branch_gt_s_imm i32 (i32.const 8960)) - (global $assembly/instructions/branch/branch_eq i32 (i32.const 8992)) - (global $assembly/instructions/branch/branch_ne i32 (i32.const 9024)) - (global $assembly/instructions/branch/branch_lt_u i32 (i32.const 9056)) - (global $assembly/instructions/branch/branch_lt_s i32 (i32.const 9088)) - (global $assembly/instructions/branch/branch_ge_u i32 (i32.const 9120)) - (global $assembly/instructions/branch/branch_ge_s i32 (i32.const 9152)) - (global $assembly/instructions/jump/jump i32 (i32.const 9184)) - (global $assembly/instructions/jump/jump_ind i32 (i32.const 9216)) - (global $assembly/instructions/jump/load_imm_jump i32 (i32.const 9248)) - (global $assembly/instructions/jump/load_imm_jump_ind i32 (i32.const 9280)) - (global $assembly/instructions/load/load_imm_64 i32 (i32.const 9312)) - (global $assembly/instructions/load/load_imm i32 (i32.const 9344)) - (global $assembly/instructions/load/load_u8 i32 (i32.const 9696)) - (global $assembly/instructions/load/load_i8 i32 (i32.const 9728)) - (global $assembly/instructions/load/load_u16 i32 (i32.const 9760)) - (global $assembly/instructions/load/load_i16 i32 (i32.const 9792)) - (global $assembly/instructions/load/load_u32 i32 (i32.const 9824)) - (global $assembly/instructions/load/load_i32 i32 (i32.const 9856)) - (global $assembly/instructions/load/load_u64 i32 (i32.const 9888)) - (global $assembly/instructions/load/load_ind_u8 i32 (i32.const 9920)) - (global $assembly/instructions/load/load_ind_i8 i32 (i32.const 9952)) - (global $assembly/instructions/load/load_ind_u16 i32 (i32.const 9984)) - (global $assembly/instructions/load/load_ind_i16 i32 (i32.const 10016)) - (global $assembly/instructions/load/load_ind_u32 i32 (i32.const 10048)) - (global $assembly/instructions/load/load_ind_i32 i32 (i32.const 10080)) - (global $assembly/instructions/load/load_ind_u64 i32 (i32.const 10112)) - (global $assembly/instructions/logic/and_imm i32 (i32.const 10144)) - (global $assembly/instructions/logic/xor_imm i32 (i32.const 10176)) - (global $assembly/instructions/logic/or_imm i32 (i32.const 10208)) - (global $assembly/instructions/logic/and i32 (i32.const 10240)) - (global $assembly/instructions/logic/xor i32 (i32.const 10272)) - (global $assembly/instructions/logic/or i32 (i32.const 10304)) - (global $assembly/instructions/logic/and_inv i32 (i32.const 10336)) - (global $assembly/instructions/logic/or_inv i32 (i32.const 10368)) - (global $assembly/instructions/logic/xnor i32 (i32.const 10400)) - (global $assembly/instructions/math/add_imm_32 i32 (i32.const 10432)) - (global $assembly/instructions/math/mul_imm_32 i32 (i32.const 10464)) - (global $assembly/instructions/math/neg_add_imm_32 i32 (i32.const 10496)) - (global $assembly/instructions/math/add_imm i32 (i32.const 10528)) - (global $assembly/instructions/math/mul_imm i32 (i32.const 10560)) - (global $assembly/instructions/math/neg_add_imm i32 (i32.const 10592)) - (global $assembly/instructions/math/add_32 i32 (i32.const 10624)) - (global $assembly/instructions/math/sub_32 i32 (i32.const 10656)) - (global $assembly/instructions/math/mul_32 i32 (i32.const 10688)) - (global $~lib/builtins/u64.MAX_VALUE i64 (i64.const -1)) - (global $assembly/instructions/math/div_u_32 i32 (i32.const 10720)) - (global $~lib/builtins/i32.MIN_VALUE i32 (i32.const -2147483648)) - (global $assembly/instructions/math/div_s_32 i32 (i32.const 10752)) - (global $assembly/instructions/math/rem_u_32 i32 (i32.const 10784)) - (global $assembly/instructions/math/rem_s_32 i32 (i32.const 10816)) - (global $assembly/instructions/math/add_64 i32 (i32.const 10848)) - (global $assembly/instructions/math/sub i32 (i32.const 10880)) - (global $assembly/instructions/math/mul i32 (i32.const 10912)) - (global $assembly/instructions/math/div_u i32 (i32.const 10944)) - (global $~lib/builtins/i64.MIN_VALUE i64 (i64.const -9223372036854775808)) - (global $assembly/instructions/math/div_s i32 (i32.const 10976)) - (global $assembly/instructions/math/rem_u i32 (i32.const 11008)) - (global $assembly/instructions/math/rem_s i32 (i32.const 11040)) - (global $assembly/instructions/math/mul_upper_s_s i32 (i32.const 11072)) - (global $assembly/instructions/math/mul_upper_u_u i32 (i32.const 11104)) - (global $assembly/instructions/math/mul_upper_s_u i32 (i32.const 11136)) - (global $assembly/instructions/math/max i32 (i32.const 11168)) - (global $assembly/instructions/math/max_u i32 (i32.const 11200)) - (global $assembly/instructions/math/min i32 (i32.const 11232)) - (global $assembly/instructions/math/min_u i32 (i32.const 11264)) - (global $assembly/instructions/misc/INVALID i32 (i32.const 11296)) - (global $assembly/instructions/misc/trap i32 (i32.const 11328)) - (global $assembly/instructions/misc/fallthrough i32 (i32.const 11360)) - (global $assembly/instructions/misc/ecalli i32 (i32.const 11392)) - (global $assembly/instructions/misc/sbrk i32 (i32.const 11568)) - (global $assembly/instructions/mov/move_reg i32 (i32.const 11600)) - (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11632)) - (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11664)) - (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11696)) - (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11728)) - (global $assembly/instructions/rot/rot_r_64_imm i32 (i32.const 11760)) - (global $assembly/instructions/rot/rot_r_64_imm_alt i32 (i32.const 11792)) - (global $assembly/instructions/rot/rot_r_32_imm i32 (i32.const 11824)) - (global $assembly/instructions/rot/rot_r_32_imm_alt i32 (i32.const 11856)) - (global $assembly/instructions/rot/rot_l_64 i32 (i32.const 11888)) - (global $assembly/instructions/rot/rot_l_32 i32 (i32.const 11920)) - (global $assembly/instructions/rot/rot_r_64 i32 (i32.const 11952)) - (global $assembly/instructions/rot/rot_r_32 i32 (i32.const 11984)) - (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 12016)) - (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 12048)) - (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 12080)) - (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 12112)) - (global $assembly/instructions/set/set_lt_u i32 (i32.const 12144)) - (global $assembly/instructions/set/set_lt_s i32 (i32.const 12176)) - (global $assembly/instructions/shift/MAX_SHIFT_64 i32 (i32.const 64)) - (global $assembly/instructions/shift/MAX_SHIFT_32 i32 (i32.const 32)) - (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 12208)) - (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 12240)) - (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 12272)) - (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 12304)) - (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 12336)) - (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 12368)) - (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 12400)) - (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 12432)) - (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 12464)) - (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 12496)) - (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 12528)) - (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 12560)) - (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 12592)) - (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 12624)) - (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12656)) - (global $assembly/instructions/shift/shlo_l i32 (i32.const 12688)) - (global $assembly/instructions/shift/shlo_r i32 (i32.const 12720)) - (global $assembly/instructions/shift/shar_r i32 (i32.const 12752)) - (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12784)) - (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12816)) - (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12848)) - (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12880)) - (global $assembly/instructions/store/store_u8 i32 (i32.const 12912)) - (global $assembly/instructions/store/store_u16 i32 (i32.const 12944)) - (global $assembly/instructions/store/store_u32 i32 (i32.const 12976)) - (global $assembly/instructions/store/store_u64 i32 (i32.const 13008)) - (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 13040)) - (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 13072)) - (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 13104)) - (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 13136)) - (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 13168)) - (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 13200)) - (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 13232)) - (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 13264)) - (global $assembly/instructions-exe/RUN i32 (i32.const 14240)) - (global $assembly/codec/MASKS i32 (i32.const 14320)) - (global $assembly/codec/variableLength i32 (i32.const 14368)) - (global $assembly/program/MAX_SKIP i32 (i32.const 24)) - (global $assembly/program/BasicBlock.NONE i32 (i32.const 0)) - (global $assembly/program/BasicBlock.START i32 (i32.const 2)) - (global $assembly/program/BasicBlock.END i32 (i32.const 4)) - (global $assembly/interpreter/Status.OK i32 (i32.const -1)) - (global $assembly/interpreter/Status.HALT i32 (i32.const 0)) - (global $assembly/interpreter/Status.PANIC i32 (i32.const 1)) - (global $assembly/interpreter/Status.FAULT i32 (i32.const 2)) - (global $assembly/interpreter/Status.HOST i32 (i32.const 3)) - (global $assembly/interpreter/Status.OOG i32 (i32.const 4)) - (global $assembly/interpreter/DjumpStatus.OK i32 (i32.const 0)) - (global $assembly/interpreter/DjumpStatus.HALT i32 (i32.const 1)) - (global $assembly/interpreter/DjumpStatus.PANIC i32 (i32.const 2)) - (global $assembly/interpreter/EXIT i32 (i32.const -65536)) - (global $assembly/interpreter/JUMP_ALIGMENT_FACTOR i32 (i32.const 2)) - (global $assembly/interpreter/MAX_U32 (mut i64) (i64.const 0)) - (global $assembly/spi/MAX_ARGS_LEN (mut i32) (i32.const 0)) - (global $assembly/spi/ARGS_SEGMENT_START (mut i32) (i32.const 0)) - (global $assembly/spi/STACK_SEGMENT_END (mut i32) (i32.const 0)) - (global $assembly/api-debugger/interpreter (mut i32) (i32.const 0)) - (global $assembly/api-utils/InputKind.Generic i32 (i32.const 0)) - (global $assembly/api-utils/InputKind.SPI i32 (i32.const 1)) - (global $assembly/api-utils/HasMetadata.Yes i32 (i32.const 0)) - (global $assembly/api-utils/HasMetadata.No i32 (i32.const 1)) - (global $~lib/builtins/u32.MAX_VALUE i32 (i32.const -1)) - (global $~lib/rt/__rtti_base i32 (i32.const 20528)) - (global $~lib/memory/__data_end i32 (i32.const 20788)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 53556)) - (global $~lib/memory/__heap_base i32 (i32.const 53556)) - (memory $0 1) - (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") - (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $2 (i32.const 140) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") - (data $3 (i32.const 220) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00\a0\00\00\00\a0\00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $4 (i32.const 268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e\00\00\00\00\00") - (data $5 (i32.const 332) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $6 (i32.const 400) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $7 (i32.const 432) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $8 (i32.const 460) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e\00\00\00\00\00\00\00\00\00") - (data $9 (i32.const 524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $10 (i32.const 576) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $11 (i32.const 604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $12 (i32.const 668) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00") - (data $13 (i32.const 700) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $14 (i32.const 764) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") - (data $15 (i32.const 796) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") - (data $16 (i32.const 828) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\04\00\00\00\00\00\00\00\00\00\00\00") - (data $17 (i32.const 860) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\05\00\00\00\00\00\00\00\00\00\00\00") - (data $18 (i32.const 892) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\06\00\00\00\00\00\00\00\00\00\00\00") - (data $19 (i32.const 924) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\07\00\00\00\00\00\00\00\00\00\00\00") - (data $20 (i32.const 956) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00") - (data $21 (i32.const 988) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\t\00\00\00\00\00\00\00\00\00\00\00") - (data $22 (i32.const 1020) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") - (data $23 (i32.const 1052) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0b\00\00\00\00\00\00\00\00\00\00\00") - (data $24 (i32.const 1084) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0c\00\00\00\00\00\00\00\00\00\00\00") - (data $25 (i32.const 1116) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00") - (data $26 (i32.const 1148) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\b0\02\00\00\10\03\00\000\03\00\00P\03\00\00p\03\00\00\90\03\00\00\b0\03\00\00\d0\03\00\00\f0\03\00\00\10\04\00\000\04\00\00P\04\00\00p\04\00\00\00\00\00\00\00\00\00\00") - (data $27 (i32.const 1228) ",\00\00\00\00\00\00\00\00\00\00\00\07\00\00\00\10\00\00\00\90\04\00\00\90\04\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $28 (i32.const 1276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $29 (i32.const 1324) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00S\00B\00R\00K\00\00\00\00\00") - (data $30 (i32.const 1356) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00T\00R\00A\00P\00\00\00\00\00") - (data $31 (i32.const 1388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H\00\00\00\00\00\00\00") - (data $32 (i32.const 1436) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I\00") - (data $33 (i32.const 1468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00") - (data $34 (i32.const 1516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008\00\00\00\00\00") - (data $35 (i32.const 1564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006\00\00\00") - (data $36 (i32.const 1612) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002\00\00\00") - (data $37 (i32.const 1660) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004\00\00\00") - (data $38 (i32.const 1708) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00J\00U\00M\00P\00\00\00\00\00") - (data $39 (i32.const 1740) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $40 (i32.const 1788) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $41 (i32.const 1836) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $42 (i32.const 1884) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $43 (i32.const 1932) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $44 (i32.const 1980) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $45 (i32.const 2028) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $46 (i32.const 2076) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $47 (i32.const 2124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $48 (i32.const 2172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $49 (i32.const 2220) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") - (data $50 (i32.const 2268) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $51 (i32.const 2316) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $52 (i32.const 2364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $53 (i32.const 2428) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") - (data $54 (i32.const 2492) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $55 (i32.const 2556) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $56 (i32.const 2620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00\00\00") - (data $57 (i32.const 2668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M\00\00\00") - (data $58 (i32.const 2716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M\00\00\00") - (data $59 (i32.const 2764) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $60 (i32.const 2828) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $61 (i32.const 2892) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $62 (i32.const 2956) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $63 (i32.const 3020) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $64 (i32.const 3084) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $65 (i32.const 3148) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $66 (i32.const 3212) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $67 (i32.const 3276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $68 (i32.const 3324) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $69 (i32.const 3388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $70 (i32.const 3452) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00") - (data $71 (i32.const 3516) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00") - (data $72 (i32.const 3580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00") - (data $73 (i32.const 3644) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00") - (data $74 (i32.const 3708) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008\00\00\00") - (data $75 (i32.const 3756) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") - (data $76 (i32.const 3804) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") - (data $77 (i32.const 3852) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S\00\00\00") - (data $78 (i32.const 3900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00") - (data $79 (i32.const 3948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006\00\00\00") - (data $80 (i32.const 3996) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002\00\00\00") - (data $81 (i32.const 4044) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004\00\00\00") - (data $82 (i32.const 4092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00") - (data $83 (i32.const 4140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008\00\00\00\00\00\00\00") - (data $84 (i32.const 4188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00") - (data $85 (i32.const 4236) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006\00\00\00\00\00") - (data $86 (i32.const 4284) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00") - (data $87 (i32.const 4332) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002\00\00\00\00\00") - (data $88 (i32.const 4380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00") - (data $89 (i32.const 4428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") - (data $90 (i32.const 4476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $91 (i32.const 4524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $92 (i32.const 4572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M\00") - (data $93 (i32.const 4604) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") - (data $94 (i32.const 4652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") - (data $95 (i32.const 4700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") - (data $96 (i32.const 4748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $97 (i32.const 4796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $98 (i32.const 4844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $99 (i32.const 4892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00") - (data $100 (i32.const 4940) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") - (data $101 (i32.const 4988) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") - (data $102 (i32.const 5036) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $103 (i32.const 5100) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $104 (i32.const 5164) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $105 (i32.const 5228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") - (data $106 (i32.const 5276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") - (data $107 (i32.const 5324) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") - (data $108 (i32.const 5372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") - (data $109 (i32.const 5420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $110 (i32.const 5468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $111 (i32.const 5516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $112 (i32.const 5564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00") - (data $113 (i32.const 5612) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $114 (i32.const 5676) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $115 (i32.const 5740) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $116 (i32.const 5804) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00\00\00\00\00") - (data $117 (i32.const 5852) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $118 (i32.const 5916) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00\00\00\00\00") - (data $119 (i32.const 5964) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $120 (i32.const 6028) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00\00\00\00\00\00\00\00\00\00\00") - (data $121 (i32.const 6076) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00\00\00\00\00\00\00\00\00\00\00") - (data $122 (i32.const 6124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00\00\00\00\00\00\00") - (data $123 (i32.const 6172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00\00\00\00\00\00\00") - (data $124 (i32.const 6220) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00\00\00\00\00\00\00") - (data $125 (i32.const 6268) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00\00\00\00\00\00\00") - (data $126 (i32.const 6316) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00") - (data $127 (i32.const 6380) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002\00") - (data $128 (i32.const 6412) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002\00") - (data $129 (i32.const 6444) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002\00") - (data $130 (i32.const 6476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $131 (i32.const 6524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $132 (i32.const 6572) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $133 (i32.const 6620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $134 (i32.const 6668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $135 (i32.const 6716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $136 (i32.const 6764) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $137 (i32.const 6812) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004\00") - (data $138 (i32.const 6844) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004\00") - (data $139 (i32.const 6876) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004\00") - (data $140 (i32.const 6908) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $141 (i32.const 6956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $142 (i32.const 7004) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $143 (i32.const 7052) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $144 (i32.const 7100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $145 (i32.const 7148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $146 (i32.const 7196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $147 (i32.const 7244) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00A\00N\00D\00\00\00\00\00\00\00") - (data $148 (i32.const 7276) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00X\00O\00R\00\00\00\00\00\00\00") - (data $149 (i32.const 7308) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00O\00R\00\00\00\00\00\00\00\00\00") - (data $150 (i32.const 7340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S\00\00\00") - (data $151 (i32.const 7388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U\00\00\00") - (data $152 (i32.const 7436) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U\00\00\00") - (data $153 (i32.const 7484) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $154 (i32.const 7532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $155 (i32.const 7580) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $156 (i32.const 7628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $157 (i32.const 7676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $158 (i32.const 7724) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $159 (i32.const 7772) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $160 (i32.const 7820) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $161 (i32.const 7868) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $162 (i32.const 7916) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V\00") - (data $163 (i32.const 7948) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00X\00N\00O\00R\00\00\00\00\00") - (data $164 (i32.const 7980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00A\00X\00\00\00\00\00\00\00") - (data $165 (i32.const 8012) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00A\00X\00_\00U\00\00\00") - (data $166 (i32.const 8044) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00I\00N\00\00\00\00\00\00\00") - (data $167 (i32.const 8076) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00I\00N\00_\00U\00\00\00") - (data $168 (i32.const 8108) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00") - (data $169 (i32.const 8156) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h\00") - (data $170 (i32.const 8204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") - (data $171 (i32.const 8268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00") - (data $172 (i32.const 8332) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\0e\00\00\00\00\00\00\00\00\00\00\00") - (data $173 (i32.const 8364) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\0f\00\00\00\00\00\00\00\00\00\00\00") - (data $174 (i32.const 8396) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\10\00\00\00\00\00\00\00\00\00\00\00") - (data $175 (i32.const 8428) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\11\00\00\00\00\00\00\00\00\00\00\00") - (data $176 (i32.const 8460) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\12\00\00\00\00\00\00\00\00\00\00\00") - (data $177 (i32.const 8492) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\13\00\00\00\00\00\00\00\00\00\00\00") - (data $178 (i32.const 8524) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\14\00\00\00\00\00\00\00\00\00\00\00") - (data $179 (i32.const 8556) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\15\00\00\00\00\00\00\00\00\00\00\00") - (data $180 (i32.const 8588) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\16\00\00\00\00\00\00\00\00\00\00\00") - (data $181 (i32.const 8620) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\17\00\00\00\00\00\00\00\00\00\00\00") - (data $182 (i32.const 8652) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\18\00\00\00\00\00\00\00\00\00\00\00") - (data $183 (i32.const 8684) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\19\00\00\00\00\00\00\00\00\00\00\00") - (data $184 (i32.const 8716) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1a\00\00\00\00\00\00\00\00\00\00\00") - (data $185 (i32.const 8748) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1b\00\00\00\00\00\00\00\00\00\00\00") - (data $186 (i32.const 8780) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1c\00\00\00\00\00\00\00\00\00\00\00") - (data $187 (i32.const 8812) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1d\00\00\00\00\00\00\00\00\00\00\00") - (data $188 (i32.const 8844) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1e\00\00\00\00\00\00\00\00\00\00\00") - (data $189 (i32.const 8876) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\1f\00\00\00\00\00\00\00\00\00\00\00") - (data $190 (i32.const 8908) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $191 (i32.const 8940) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00!\00\00\00\00\00\00\00\00\00\00\00") - (data $192 (i32.const 8972) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\"\00\00\00\00\00\00\00\00\00\00\00") - (data $193 (i32.const 9004) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00#\00\00\00\00\00\00\00\00\00\00\00") - (data $194 (i32.const 9036) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00$\00\00\00\00\00\00\00\00\00\00\00") - (data $195 (i32.const 9068) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00%\00\00\00\00\00\00\00\00\00\00\00") - (data $196 (i32.const 9100) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00&\00\00\00\00\00\00\00\00\00\00\00") - (data $197 (i32.const 9132) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\'\00\00\00\00\00\00\00\00\00\00\00") - (data $198 (i32.const 9164) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") - (data $199 (i32.const 9196) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") - (data $200 (i32.const 9228) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00*\00\00\00\00\00\00\00\00\00\00\00") - (data $201 (i32.const 9260) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00+\00\00\00\00\00\00\00\00\00\00\00") - (data $202 (i32.const 9292) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") - (data $203 (i32.const 9324) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00-\00\00\00\00\00\00\00\00\00\00\00") - (data $204 (i32.const 9356) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t\00\00\00\00\00\00\00\00\00") - (data $205 (i32.const 9420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s\00\00\00\00\00\00\00") - (data $206 (i32.const 9468) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $207 (i32.const 9596) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $208 (i32.const 9676) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00.\00\00\00\00\00\00\00\00\00\00\00") - (data $209 (i32.const 9708) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00/\00\00\00\00\00\00\00\00\00\00\00") - (data $210 (i32.const 9740) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\000\00\00\00\00\00\00\00\00\00\00\00") - (data $211 (i32.const 9772) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\001\00\00\00\00\00\00\00\00\00\00\00") - (data $212 (i32.const 9804) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\002\00\00\00\00\00\00\00\00\00\00\00") - (data $213 (i32.const 9836) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\003\00\00\00\00\00\00\00\00\00\00\00") - (data $214 (i32.const 9868) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\004\00\00\00\00\00\00\00\00\00\00\00") - (data $215 (i32.const 9900) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\005\00\00\00\00\00\00\00\00\00\00\00") - (data $216 (i32.const 9932) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\006\00\00\00\00\00\00\00\00\00\00\00") - (data $217 (i32.const 9964) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\007\00\00\00\00\00\00\00\00\00\00\00") - (data $218 (i32.const 9996) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\008\00\00\00\00\00\00\00\00\00\00\00") - (data $219 (i32.const 10028) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\009\00\00\00\00\00\00\00\00\00\00\00") - (data $220 (i32.const 10060) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00:\00\00\00\00\00\00\00\00\00\00\00") - (data $221 (i32.const 10092) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00;\00\00\00\00\00\00\00\00\00\00\00") - (data $222 (i32.const 10124) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00<\00\00\00\00\00\00\00\00\00\00\00") - (data $223 (i32.const 10156) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00=\00\00\00\00\00\00\00\00\00\00\00") - (data $224 (i32.const 10188) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00>\00\00\00\00\00\00\00\00\00\00\00") - (data $225 (i32.const 10220) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00?\00\00\00\00\00\00\00\00\00\00\00") - (data $226 (i32.const 10252) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00@\00\00\00\00\00\00\00\00\00\00\00") - (data $227 (i32.const 10284) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00A\00\00\00\00\00\00\00\00\00\00\00") - (data $228 (i32.const 10316) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00B\00\00\00\00\00\00\00\00\00\00\00") - (data $229 (i32.const 10348) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00C\00\00\00\00\00\00\00\00\00\00\00") - (data $230 (i32.const 10380) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00D\00\00\00\00\00\00\00\00\00\00\00") - (data $231 (i32.const 10412) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00E\00\00\00\00\00\00\00\00\00\00\00") - (data $232 (i32.const 10444) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00F\00\00\00\00\00\00\00\00\00\00\00") - (data $233 (i32.const 10476) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00G\00\00\00\00\00\00\00\00\00\00\00") - (data $234 (i32.const 10508) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00H\00\00\00\00\00\00\00\00\00\00\00") - (data $235 (i32.const 10540) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00I\00\00\00\00\00\00\00\00\00\00\00") - (data $236 (i32.const 10572) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00J\00\00\00\00\00\00\00\00\00\00\00") - (data $237 (i32.const 10604) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00K\00\00\00\00\00\00\00\00\00\00\00") - (data $238 (i32.const 10636) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00L\00\00\00\00\00\00\00\00\00\00\00") - (data $239 (i32.const 10668) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00M\00\00\00\00\00\00\00\00\00\00\00") - (data $240 (i32.const 10700) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00N\00\00\00\00\00\00\00\00\00\00\00") - (data $241 (i32.const 10732) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00O\00\00\00\00\00\00\00\00\00\00\00") - (data $242 (i32.const 10764) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00P\00\00\00\00\00\00\00\00\00\00\00") - (data $243 (i32.const 10796) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Q\00\00\00\00\00\00\00\00\00\00\00") - (data $244 (i32.const 10828) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00R\00\00\00\00\00\00\00\00\00\00\00") - (data $245 (i32.const 10860) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00S\00\00\00\00\00\00\00\00\00\00\00") - (data $246 (i32.const 10892) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00T\00\00\00\00\00\00\00\00\00\00\00") - (data $247 (i32.const 10924) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00U\00\00\00\00\00\00\00\00\00\00\00") - (data $248 (i32.const 10956) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00V\00\00\00\00\00\00\00\00\00\00\00") - (data $249 (i32.const 10988) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00W\00\00\00\00\00\00\00\00\00\00\00") - (data $250 (i32.const 11020) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00X\00\00\00\00\00\00\00\00\00\00\00") - (data $251 (i32.const 11052) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Y\00\00\00\00\00\00\00\00\00\00\00") - (data $252 (i32.const 11084) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00Z\00\00\00\00\00\00\00\00\00\00\00") - (data $253 (i32.const 11116) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00[\00\00\00\00\00\00\00\00\00\00\00") - (data $254 (i32.const 11148) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\\\00\00\00\00\00\00\00\00\00\00\00") - (data $255 (i32.const 11180) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") - (data $256 (i32.const 11212) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00^\00\00\00\00\00\00\00\00\00\00\00") - (data $257 (i32.const 11244) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00_\00\00\00\00\00\00\00\00\00\00\00") - (data $258 (i32.const 11276) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00`\00\00\00\00\00\00\00\00\00\00\00") - (data $259 (i32.const 11308) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") - (data $260 (i32.const 11340) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") - (data $261 (i32.const 11372) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") - (data $262 (i32.const 11404) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y\00") - (data $263 (i32.const 11452) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.\00") - (data $264 (i32.const 11548) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") - (data $265 (i32.const 11580) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00e\00\00\00\00\00\00\00\00\00\00\00") - (data $266 (i32.const 11612) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00f\00\00\00\00\00\00\00\00\00\00\00") - (data $267 (i32.const 11644) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00g\00\00\00\00\00\00\00\00\00\00\00") - (data $268 (i32.const 11676) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00h\00\00\00\00\00\00\00\00\00\00\00") - (data $269 (i32.const 11708) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00i\00\00\00\00\00\00\00\00\00\00\00") - (data $270 (i32.const 11740) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00j\00\00\00\00\00\00\00\00\00\00\00") - (data $271 (i32.const 11772) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00k\00\00\00\00\00\00\00\00\00\00\00") - (data $272 (i32.const 11804) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00l\00\00\00\00\00\00\00\00\00\00\00") - (data $273 (i32.const 11836) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00m\00\00\00\00\00\00\00\00\00\00\00") - (data $274 (i32.const 11868) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00n\00\00\00\00\00\00\00\00\00\00\00") - (data $275 (i32.const 11900) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00o\00\00\00\00\00\00\00\00\00\00\00") - (data $276 (i32.const 11932) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00p\00\00\00\00\00\00\00\00\00\00\00") - (data $277 (i32.const 11964) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00q\00\00\00\00\00\00\00\00\00\00\00") - (data $278 (i32.const 11996) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00r\00\00\00\00\00\00\00\00\00\00\00") - (data $279 (i32.const 12028) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $280 (i32.const 12060) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00t\00\00\00\00\00\00\00\00\00\00\00") - (data $281 (i32.const 12092) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00u\00\00\00\00\00\00\00\00\00\00\00") - (data $282 (i32.const 12124) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00v\00\00\00\00\00\00\00\00\00\00\00") - (data $283 (i32.const 12156) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00w\00\00\00\00\00\00\00\00\00\00\00") - (data $284 (i32.const 12188) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00x\00\00\00\00\00\00\00\00\00\00\00") - (data $285 (i32.const 12220) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00y\00\00\00\00\00\00\00\00\00\00\00") - (data $286 (i32.const 12252) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00z\00\00\00\00\00\00\00\00\00\00\00") - (data $287 (i32.const 12284) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00{\00\00\00\00\00\00\00\00\00\00\00") - (data $288 (i32.const 12316) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00|\00\00\00\00\00\00\00\00\00\00\00") - (data $289 (i32.const 12348) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00}\00\00\00\00\00\00\00\00\00\00\00") - (data $290 (i32.const 12380) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00~\00\00\00\00\00\00\00\00\00\00\00") - (data $291 (i32.const 12412) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\7f\00\00\00\00\00\00\00\00\00\00\00") - (data $292 (i32.const 12444) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\80\00\00\00\00\00\00\00\00\00\00\00") - (data $293 (i32.const 12476) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\81\00\00\00\00\00\00\00\00\00\00\00") - (data $294 (i32.const 12508) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\82\00\00\00\00\00\00\00\00\00\00\00") - (data $295 (i32.const 12540) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\83\00\00\00\00\00\00\00\00\00\00\00") - (data $296 (i32.const 12572) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\84\00\00\00\00\00\00\00\00\00\00\00") - (data $297 (i32.const 12604) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\85\00\00\00\00\00\00\00\00\00\00\00") - (data $298 (i32.const 12636) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\86\00\00\00\00\00\00\00\00\00\00\00") - (data $299 (i32.const 12668) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\87\00\00\00\00\00\00\00\00\00\00\00") - (data $300 (i32.const 12700) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\88\00\00\00\00\00\00\00\00\00\00\00") - (data $301 (i32.const 12732) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\89\00\00\00\00\00\00\00\00\00\00\00") - (data $302 (i32.const 12764) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8a\00\00\00\00\00\00\00\00\00\00\00") - (data $303 (i32.const 12796) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8b\00\00\00\00\00\00\00\00\00\00\00") - (data $304 (i32.const 12828) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8c\00\00\00\00\00\00\00\00\00\00\00") - (data $305 (i32.const 12860) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8d\00\00\00\00\00\00\00\00\00\00\00") - (data $306 (i32.const 12892) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8e\00\00\00\00\00\00\00\00\00\00\00") - (data $307 (i32.const 12924) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\8f\00\00\00\00\00\00\00\00\00\00\00") - (data $308 (i32.const 12956) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\90\00\00\00\00\00\00\00\00\00\00\00") - (data $309 (i32.const 12988) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\91\00\00\00\00\00\00\00\00\00\00\00") - (data $310 (i32.const 13020) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\92\00\00\00\00\00\00\00\00\00\00\00") - (data $311 (i32.const 13052) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\93\00\00\00\00\00\00\00\00\00\00\00") - (data $312 (i32.const 13084) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\94\00\00\00\00\00\00\00\00\00\00\00") - (data $313 (i32.const 13116) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\95\00\00\00\00\00\00\00\00\00\00\00") - (data $314 (i32.const 13148) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\96\00\00\00\00\00\00\00\00\00\00\00") - (data $315 (i32.const 13180) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\97\00\00\00\00\00\00\00\00\00\00\00") - (data $316 (i32.const 13212) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\98\00\00\00\00\00\00\00\00\00\00\00") - (data $317 (i32.const 13244) "\1c\00\00\00\00\00\00\00\00\00\00\00\14\00\00\00\08\00\00\00\99\00\00\00\00\00\00\00\00\00\00\00") - (data $318 (i32.const 13276) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00@,\00\00`,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\80,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00`$\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\f01\00\00\102\00\0002\00\00P2\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\e0#\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\00$\00\00\80$\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00p2\00\00\902\00\00\b02\00\00\d02\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\f02\00\00\103\00\0003\00\00P3\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 $\00\00\e0!\00\00\00\"\00\00 \"\00\00@\"\00\00`\"\00\00\80\"\00\00\a0\"\00\00\c0\"\00\00\e0\"\00\00\00#\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00P-\00\000-\00\00\a0 \00\00\c0 \00\00\e0 \00\00\00!\00\00 !\00\00@!\00\00`!\00\00\80!\00\00\a0!\00\00\c0!\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00p3\00\00\903\00\00\b03\00\00\d03\00\00\c0&\00\00\e0&\00\00\00\'\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\c0(\00\00\a0\'\00\00\c0\'\00\00\e0\'\00\00\e0(\00\00\f0.\00\00\10/\00\00\b0/\00\00\d0/\00\00\f0/\00\00\00)\00\000/\00\00P/\00\00\100\00\0000\00\00P0\00\00p-\00\00\90-\00\00 )\00\00@)\00\00p0\00\00\900\00\00\b00\00\00`)\00\00\d00\00\00\f00\00\00\101\00\00\f0-\00\00\10.\00\000.\00\00P.\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 #\00\00@#\00\00`#\00\00\80#\00\00\a0#\00\00\c0#\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00@$\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00 ,\00\00\80)\00\00\a0)\00\00\c0)\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\0001\00\00P1\00\00p1\00\00`*\00\00\80*\00\00\a0*\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00\901\00\00\b01\00\00\d01\00\00\00(\00\00 (\00\00@(\00\00@+\00\00`+\00\00\80+\00\00p/\00\00\90/\00\00\b0-\00\00\d0-\00\00p.\00\00\90.\00\00\b0.\00\00\d0.\00\00`(\00\00\80(\00\00\a0(\00\00\a0+\00\00\c0+\00\00\e0+\00\00\00,\00\00") - (data $319 (i32.const 14220) ",\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\10\00\00\00\f03\00\00\f03\00\00\9c\03\00\00\e7\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $320 (i32.const 14268) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80\00\00\00\00") - (data $321 (i32.const 14300) ",\00\00\00\00\00\00\00\00\00\00\00\1b\00\00\00\10\00\00\00\d07\00\00\d07\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $322 (i32.const 14348) "\1c\00\00\00\00\00\00\00\00\00\00\00\1c\00\00\00\08\00\00\00\9a\00\00\00\00\00\00\00\00\00\00\00") - (data $323 (i32.const 14380) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>\00\00\00") - (data $324 (i32.const 14460) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $325 (i32.const 14492) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!\00\00\00\00\00\00\00\00\00\00\00") - (data $326 (i32.const 14604) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00i\00n\00t\00e\00r\00n\00a\00l\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $327 (i32.const 14684) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $328 (i32.const 14812) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") - (data $329 (i32.const 14844) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006\00\00\00\00\00\00\00\00\00") - (data $330 (i32.const 14972) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") - (data $331 (i32.const 15036) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\000\00\00\00\00\00\00\00\00\00\00\00") - (data $332 (i32.const 15068) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\00") - (data $333 (i32.const 15468) "\1c\04\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $334 (i32.const 16524) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z\00\00\00\00\00") - (data $335 (i32.const 16620) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00:\00 \00\00\00\00\00\00\00\00\00") - (data $336 (i32.const 16652) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") - (data $337 (i32.const 16684) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") - (data $338 (i32.const 16716) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00 A\00\00\00\00\00\00@A\00\00") - (data $339 (i32.const 16748) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $340 (i32.const 16780) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00,\00 \00\00\00\00\00\00\00\00\00") - (data $341 (i32.const 16812) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\80A\00\00\00\00\00\00\a0A\00\00") - (data $342 (i32.const 16844) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 \00\00\00\00\00\00\00\00\00") - (data $343 (i32.const 16924) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $344 (i32.const 17004) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $345 (i32.const 17036) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $346 (i32.const 17100) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 \00\00\00\00\00\00\00") - (data $347 (i32.const 17180) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $348 (i32.const 17244) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 \00\00\00") - (data $349 (i32.const 17324) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $350 (i32.const 17372) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00pC\00\00\00\00\00\00\c0C\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $351 (i32.const 17420) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 \00\00\00\00\00\00\00\00\00") - (data $352 (i32.const 17532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $353 (i32.const 17580) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00 D\00\00\00\00\00\00\90D\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $354 (i32.const 17628) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00A\00r\00g\00u\00m\00e\00n\00t\00s\00 \00l\00e\00n\00g\00t\00h\00 \00i\00s\00 \00t\00o\00o\00 \00b\00i\00g\00.\00 \00G\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00") - (data $355 (i32.const 17724) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00m\00a\00x\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $356 (i32.const 17772) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00\f0D\00\00\00\00\00\00PE\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $357 (i32.const 17820) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00s\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $358 (i32.const 17884) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") - (data $359 (i32.const 18012) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $360 (i32.const 18044) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 \00") - (data $361 (i32.const 18140) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $362 (i32.const 18204) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!\00\00\00\00\00\00\00") - (data $363 (i32.const 18316) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00d\00e\00b\00u\00g\00g\00e\00r\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $364 (i32.const 18396) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00") - (data $365 (i32.const 18492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 \00\00\00\00\00") - (data $366 (i32.const 18540) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00\f0G\00\00\00\00\00\00PH\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $367 (i32.const 18588) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $368 (i32.const 18620) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $369 (i32.const 18652) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $370 (i32.const 18684) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t\00") - (data $371 (i32.const 18732) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $372 (i32.const 18812) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $373 (i32.const 18844) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $374 (i32.const 18876) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $375 (i32.const 18908) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $376 (i32.const 18940) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 \00") - (data $377 (i32.const 18988) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00u\00t\00i\00l\00s\00.\00t\00s\00\00\00") - (data $378 (i32.const 19052) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00g\00a\00s\00-\00c\00o\00s\00t\00s\00.\00t\00s\00\00\00") - (data $379 (i32.const 19116) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $380 (i32.const 19148) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $381 (i32.const 19180) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $382 (i32.const 19212) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $383 (i32.const 19244) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n\00\00\00\00\00\00\00") - (data $384 (i32.const 19292) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\000\00x\00\00\00\00\00\00\00\00\00") - (data $385 (i32.const 19324) "\1c\00\00\00\00\00\00\00\00\00\00\00:\00\00\00\08\00\00\00\9b\00\00\00\00\00\00\00\00\00\00\00") - (data $386 (i32.const 19356) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00\n\00\n\00\00\00\00\00\00\00\00\00") - (data $387 (i32.const 19388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 \00\00\00\00\00") - (data $388 (i32.const 19436) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $389 (i32.const 19484) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\d0K\00\00\00\00\00\00\00L\00\00") - (data $390 (i32.const 19516) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\d0K\00\00\00\00\00\00\00L\00\00") - (data $391 (i32.const 19548) "\1c\00\00\00\00\00\00\00\00\00\00\00>\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") - (data $392 (i32.const 19580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 \00") - (data $393 (i32.const 19644) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00E\00x\00i\00t\00 \00c\00o\00d\00e\00:\00 \00\00\00\00\00\00\00") - (data $394 (i32.const 19692) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00P\00C\00 \00=\00 \00\00\00") - (data $395 (i32.const 19724) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00G\00A\00S\00 \00=\00 \00") - (data $396 (i32.const 19756) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $397 (i32.const 19804) "\1c\00\00\00\00\00\00\00\00\00\00\00>\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") - (data $398 (i32.const 19836) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 \00") - (data $399 (i32.const 19884) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00(\00\00\00\00\00\00\00\00\00") - (data $400 (i32.const 19916) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\14\00\00\00\90M\00\00\00\00\00\00\c0M\00\00\00\00\00\00@A\00\00\00\00\00\00\00\00\00\00") - (data $401 (i32.const 19964) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00") - (data $402 (i32.const 20028) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 \00\00\00") - (data $403 (i32.const 20076) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x\00") - (data $404 (i32.const 20108) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 \00\00\00") - (data $405 (i32.const 20140) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00,\00\n\00 \00 \00\00\00\00\00") - (data $406 (i32.const 20172) "|\00\00\00\03\00\00\00\00\00\00\00%\00\00\00`\00\00\00PN\00\00\00\00\00\00\c0M\00\00\00\00\00\00\80N\00\00\00\00\00\00\a0N\00\00\00\00\00\00\c0M\00\00\00\00\00\00\80N\00\00\00\00\00\00\c0N\00\00\00\00\00\00\c0M\00\00\00\00\00\00\80N\00\00\00\00\00\00\c0N\00\00\00\00\00\00\c0M\00\00\00\00\00\00\80N\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $407 (i32.const 20300) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $408 (i32.const 20332) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $409 (i32.const 20364) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $410 (i32.const 20396) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d\00\00\00") - (data $411 (i32.const 20460) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d\00\00\00\00\00") - (data $412 (i32.const 20528) "@\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\02A\00\00B\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\01\00\00\00\00\00\00\00\00\00\00$\t\00\00 \00\00\00\04A\00\00\02\01\00\00d\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00 \00\00\00\00\00\00\00\00\00\00\00 \00\00\00\02A\00\00 \00\00\00\02A\00\00\00\00\00\00\02A\00\00 \00\00\00 \00\00\00 \00\00\00\02A\00\00\02\02\00\00\10A\02\00\00\00\00\00\00\00\00\00\00\00\00\00\02A\00\00\00\00\00\00\00\00\00\00") - (table $0 158 158 funcref) - (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/codec~anonymous|0 $assembly/api-utils/disassemble~anonymous|0 $assembly/api-internal/executeProgram~anonymous|0 $assembly/api-internal/executeProgram~anonymous|1) - (export "nextStep" (func $assembly/api-debugger/nextStep)) - (export "nSteps" (func $assembly/api-debugger/nSteps)) - (export "getProgramCounter" (func $assembly/api-debugger/getProgramCounter)) - (export "setNextProgramCounter" (func $assembly/api-debugger/setNextProgramCounter)) - (export "getStatus" (func $assembly/api-debugger/getStatus)) - (export "getExitArg" (func $assembly/api-debugger/getExitArg)) - (export "getGasLeft" (func $assembly/api-debugger/getGasLeft)) - (export "setGasLeft" (func $assembly/api-debugger/setGasLeft)) - (export "getRegister" (func $assembly/api-debugger/getRegister)) - (export "setRegister" (func $assembly/api-debugger/setRegister)) - (export "getRegisters" (func $assembly/api-debugger/getRegisters)) - (export "getPageDump" (func $assembly/api-debugger/getPageDump)) - (export "getMemory" (func $assembly/api-debugger/getMemory)) - (export "InputKind.Generic" (global $assembly/api-utils/InputKind.Generic)) - (export "InputKind.SPI" (global $assembly/api-utils/InputKind.SPI)) - (export "HasMetadata.Yes" (global $assembly/api-utils/HasMetadata.Yes)) - (export "HasMetadata.No" (global $assembly/api-utils/HasMetadata.No)) - (export "__new" (func $~lib/rt/itcms/__new)) - (export "__pin" (func $~lib/rt/itcms/__pin)) - (export "__unpin" (func $~lib/rt/itcms/__unpin)) - (export "__collect" (func $~lib/rt/itcms/__collect)) - (export "__rtti_base" (global $~lib/rt/__rtti_base)) - (export "memory" (memory $0)) - (export "__setArgumentsLength" (func $~setArgumentsLength)) - (export "getAssembly" (func $export:assembly/api-internal/getAssembly)) - (export "wrapAsProgram" (func $export:assembly/program-build/wrapAsProgram)) - (export "resetJAM" (func $export:assembly/api-debugger/resetJAM@varargs)) - (export "resetGeneric" (func $export:assembly/api-debugger/resetGeneric@varargs)) - (export "resetGenericWithMemory" (func $export:assembly/api-debugger/resetGenericWithMemory@varargs)) - (export "setRegisters" (func $export:assembly/api-debugger/setRegisters)) - (export "setMemory" (func $export:assembly/api-debugger/setMemory)) - (export "getGasCosts" (func $export:assembly/api-utils/getGasCosts)) - (export "disassemble" (func $export:assembly/api-utils/disassemble)) - (export "prepareProgram" (func $export:assembly/api-utils/prepareProgram)) - (export "runProgram" (func $export:assembly/api-utils/runProgram@varargs)) - (start $~start) - (func $~lib/rt/itcms/Object#set:nextWithColor (param $this i32) (param $nextWithColor i32) - local.get $this - local.get $nextWithColor - i32.store offset=4 - ) - (func $~lib/rt/itcms/Object#set:prev (param $this i32) (param $prev i32) - local.get $this - local.get $prev - i32.store offset=8 - ) - (func $~lib/rt/itcms/initLazy (param $space i32) (result i32) - local.get $space - local.get $space - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $space - local.get $space - call $~lib/rt/itcms/Object#set:prev - local.get $space - return - ) - (func $~lib/rt/itcms/Object#get:nextWithColor (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/rt/itcms/Object#get:next (param $this i32) (result i32) - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.const -1 - i32.xor - i32.and - return - ) - (func $~lib/rt/itcms/Object#get:color (param $this i32) (result i32) - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.and - return - ) - (func $~lib/rt/itcms/visitRoots (param $cookie i32) - (local $pn i32) - (local $iter i32) - local.get $cookie - call $~lib/rt/__visit_globals - global.get $~lib/rt/itcms/pinSpace - local.set $pn - local.get $pn - call $~lib/rt/itcms/Object#get:next - local.set $iter - loop $while-continue|0 - local.get $iter - local.get $pn - i32.ne - if - i32.const 1 - drop - local.get $iter - call $~lib/rt/itcms/Object#get:color - i32.const 3 - i32.eq - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 160 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $iter - i32.const 20 - i32.add - local.get $cookie - call $~lib/rt/__visit_members - local.get $iter - call $~lib/rt/itcms/Object#get:next - local.set $iter - br $while-continue|0 - end - end - ) - (func $~lib/rt/itcms/Object#set:color (param $this i32) (param $color i32) - local.get $this - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $color - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - ) - (func $~lib/rt/itcms/Object#get:prev (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/rt/itcms/Object#set:next (param $this i32) (param $obj i32) - local.get $this - local.get $obj - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.and - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - ) - (func $~lib/rt/itcms/Object#unlink (param $this i32) - (local $next i32) - (local $prev i32) - local.get $this - call $~lib/rt/itcms/Object#get:next - local.set $next - local.get $next - i32.const 0 - i32.eq - if - i32.const 1 - drop - local.get $this - call $~lib/rt/itcms/Object#get:prev - i32.const 0 - i32.eq - if (result i32) - local.get $this - global.get $~lib/memory/__heap_base - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 128 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - return - end - local.get $this - call $~lib/rt/itcms/Object#get:prev - local.set $prev - i32.const 1 - drop - local.get $prev - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 132 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $next - local.get $prev - call $~lib/rt/itcms/Object#set:prev - local.get $prev - local.get $next - call $~lib/rt/itcms/Object#set:next - ) - (func $~lib/rt/itcms/Object#get:rtId (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/shared/typeinfo/Typeinfo#get:flags (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/__typeinfo (param $id i32) (result i32) - (local $ptr i32) - global.get $~lib/rt/__rtti_base - local.set $ptr - local.get $id - local.get $ptr - i32.load - i32.gt_u - if - i32.const 480 - i32.const 544 - i32.const 21 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $ptr - i32.const 4 - i32.add - local.get $id - i32.const 4 - i32.mul - i32.add - call $~lib/shared/typeinfo/Typeinfo#get:flags - return - ) - (func $~lib/rt/itcms/Object#get:isPointerfree (param $this i32) (result i32) - (local $rtId i32) - local.get $this - call $~lib/rt/itcms/Object#get:rtId - local.set $rtId - local.get $rtId - i32.const 2 - i32.le_u - if (result i32) - i32.const 1 - else - local.get $rtId - call $~lib/rt/__typeinfo - i32.const 32 - i32.and - i32.const 0 - i32.ne - end - return - ) - (func $~lib/rt/itcms/Object#linkTo (param $this i32) (param $list i32) (param $withColor i32) - (local $prev i32) - local.get $list - call $~lib/rt/itcms/Object#get:prev - local.set $prev - local.get $this - local.get $list - local.get $withColor - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $this - local.get $prev - call $~lib/rt/itcms/Object#set:prev - local.get $prev - local.get $this - call $~lib/rt/itcms/Object#set:next - local.get $list - local.get $this - call $~lib/rt/itcms/Object#set:prev - ) - (func $~lib/rt/itcms/Object#makeGray (param $this i32) - (local $1 i32) - local.get $this - global.get $~lib/rt/itcms/iter - i32.eq - if - local.get $this - call $~lib/rt/itcms/Object#get:prev - local.tee $1 - i32.eqz - if (result i32) - i32.const 0 - i32.const 352 - i32.const 148 - i32.const 30 - call $~lib/builtins/abort - unreachable - else - local.get $1 - end - global.set $~lib/rt/itcms/iter - end - local.get $this - call $~lib/rt/itcms/Object#unlink - local.get $this - global.get $~lib/rt/itcms/toSpace - local.get $this - call $~lib/rt/itcms/Object#get:isPointerfree - if (result i32) - global.get $~lib/rt/itcms/white - i32.eqz - else - i32.const 2 - end - call $~lib/rt/itcms/Object#linkTo - ) - (func $~lib/rt/itcms/__visit (param $ptr i32) (param $cookie i32) - (local $obj i32) - local.get $ptr - i32.eqz - if - return - end - local.get $ptr - i32.const 20 - i32.sub - local.set $obj - i32.const 0 - drop - local.get $obj - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eq - if - local.get $obj - call $~lib/rt/itcms/Object#makeGray - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.add - global.set $~lib/rt/itcms/visitCount - end - ) - (func $~lib/rt/itcms/visitStack (param $cookie i32) - (local $ptr i32) - global.get $~lib/memory/__stack_pointer - local.set $ptr - loop $while-continue|0 - local.get $ptr - global.get $~lib/memory/__heap_base - i32.lt_u - if - local.get $ptr - i32.load - local.get $cookie - call $~lib/rt/itcms/__visit - local.get $ptr - i32.const 4 - i32.add - local.set $ptr - br $while-continue|0 - end - end - ) - (func $~lib/rt/common/BLOCK#get:mmInfo (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/itcms/Object#get:size (param $this i32) (result i32) - i32.const 4 - local.get $this - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - return - ) - (func $~lib/rt/tlsf/Root#set:flMap (param $this i32) (param $flMap i32) - local.get $this - local.get $flMap - i32.store - ) - (func $~lib/rt/common/BLOCK#set:mmInfo (param $this i32) (param $mmInfo i32) - local.get $this - local.get $mmInfo - i32.store - ) - (func $~lib/rt/tlsf/Block#set:prev (param $this i32) (param $prev i32) - local.get $this - local.get $prev - i32.store offset=4 - ) - (func $~lib/rt/tlsf/Block#set:next (param $this i32) (param $next i32) - local.get $this - local.get $next - i32.store offset=8 - ) - (func $~lib/rt/tlsf/Block#get:prev (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/rt/tlsf/Block#get:next (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/rt/tlsf/Root#get:flMap (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/tlsf/removeBlock (param $root i32) (param $block i32) - (local $blockInfo i32) - (local $size i32) - (local $fl i32) - (local $sl i32) - (local $6 i32) - (local $7 i32) - (local $boundedSize i32) - (local $prev i32) - (local $next i32) - (local $root|11 i32) - (local $fl|12 i32) - (local $sl|13 i32) - (local $root|14 i32) - (local $fl|15 i32) - (local $sl|16 i32) - (local $head i32) - (local $root|18 i32) - (local $fl|19 i32) - (local $slMap i32) - (local $root|21 i32) - (local $fl|22 i32) - (local $slMap|23 i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $blockInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 268 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.set $size - i32.const 1 - drop - local.get $size - i32.const 12 - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 270 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - local.tee $6 - i32.const 1073741820 - local.tee $7 - local.get $6 - local.get $7 - i32.lt_u - select - local.set $boundedSize - i32.const 31 - local.get $boundedSize - i32.clz - i32.sub - local.set $fl - local.get $boundedSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 284 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $block - call $~lib/rt/tlsf/Block#get:prev - local.set $prev - local.get $block - call $~lib/rt/tlsf/Block#get:next - local.set $next - local.get $prev - if - local.get $prev - local.get $next - call $~lib/rt/tlsf/Block#set:next - end - local.get $next - if - local.get $next - local.get $prev - call $~lib/rt/tlsf/Block#set:prev - end - local.get $block - block $~lib/rt/tlsf/GETHEAD|inlined.0 (result i32) - local.get $root - local.set $root|11 - local.get $fl - local.set $fl|12 - local.get $sl - local.set $sl|13 - local.get $root|11 - local.get $fl|12 - i32.const 4 - i32.shl - local.get $sl|13 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.0 - end - i32.eq - if - local.get $root - local.set $root|14 - local.get $fl - local.set $fl|15 - local.get $sl - local.set $sl|16 - local.get $next - local.set $head - local.get $root|14 - local.get $fl|15 - i32.const 4 - i32.shl - local.get $sl|16 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head - i32.store offset=96 - local.get $next - i32.eqz - if - block $~lib/rt/tlsf/GETSL|inlined.0 (result i32) - local.get $root - local.set $root|18 - local.get $fl - local.set $fl|19 - local.get $root|18 - local.get $fl|19 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.0 - end - local.set $slMap - local.get $root - local.set $root|21 - local.get $fl - local.set $fl|22 - local.get $slMap - i32.const 1 - local.get $sl - i32.shl - i32.const -1 - i32.xor - i32.and - local.tee $slMap - local.set $slMap|23 - local.get $root|21 - local.get $fl|22 - i32.const 2 - i32.shl - i32.add - local.get $slMap|23 - i32.store offset=4 - local.get $slMap - i32.eqz - if - local.get $root - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 1 - local.get $fl - i32.shl - i32.const -1 - i32.xor - i32.and - call $~lib/rt/tlsf/Root#set:flMap - end - end - end - ) - (func $~lib/rt/tlsf/insertBlock (param $root i32) (param $block i32) - (local $blockInfo i32) - (local $block|3 i32) - (local $right i32) - (local $rightInfo i32) - (local $block|6 i32) - (local $block|7 i32) - (local $left i32) - (local $leftInfo i32) - (local $size i32) - (local $fl i32) - (local $sl i32) - (local $13 i32) - (local $14 i32) - (local $boundedSize i32) - (local $root|16 i32) - (local $fl|17 i32) - (local $sl|18 i32) - (local $head i32) - (local $root|20 i32) - (local $fl|21 i32) - (local $sl|22 i32) - (local $head|23 i32) - (local $root|24 i32) - (local $fl|25 i32) - (local $root|26 i32) - (local $fl|27 i32) - (local $slMap i32) - i32.const 1 - drop - local.get $block - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 201 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $blockInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 203 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETRIGHT|inlined.0 (result i32) - local.get $block - local.set $block|3 - local.get $block|3 - i32.const 4 - i32.add - local.get $block|3 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.0 - end - local.set $right - local.get $right - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $rightInfo - local.get $rightInfo - i32.const 1 - i32.and - if - local.get $root - local.get $right - call $~lib/rt/tlsf/removeBlock - local.get $block - local.get $blockInfo - i32.const 4 - i32.add - local.get $rightInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - local.tee $blockInfo - call $~lib/rt/common/BLOCK#set:mmInfo - block $~lib/rt/tlsf/GETRIGHT|inlined.1 (result i32) - local.get $block - local.set $block|6 - local.get $block|6 - i32.const 4 - i32.add - local.get $block|6 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.1 - end - local.set $right - local.get $right - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $rightInfo - end - local.get $blockInfo - i32.const 2 - i32.and - if - block $~lib/rt/tlsf/GETFREELEFT|inlined.0 (result i32) - local.get $block - local.set $block|7 - local.get $block|7 - i32.const 4 - i32.sub - i32.load - br $~lib/rt/tlsf/GETFREELEFT|inlined.0 - end - local.set $left - local.get $left - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $leftInfo - i32.const 1 - drop - local.get $leftInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 221 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $root - local.get $left - call $~lib/rt/tlsf/removeBlock - local.get $left - local.set $block - local.get $block - local.get $leftInfo - i32.const 4 - i32.add - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - local.tee $blockInfo - call $~lib/rt/common/BLOCK#set:mmInfo - end - local.get $right - local.get $rightInfo - i32.const 2 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.set $size - i32.const 1 - drop - local.get $size - i32.const 12 - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 233 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - i32.const 1 - drop - local.get $block - i32.const 4 - i32.add - local.get $size - i32.add - local.get $right - i32.eq - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 234 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $right - i32.const 4 - i32.sub - local.get $block - i32.store - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - local.tee $13 - i32.const 1073741820 - local.tee $14 - local.get $13 - local.get $14 - i32.lt_u - select - local.set $boundedSize - i32.const 31 - local.get $boundedSize - i32.clz - i32.sub - local.set $fl - local.get $boundedSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 251 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETHEAD|inlined.1 (result i32) - local.get $root - local.set $root|16 - local.get $fl - local.set $fl|17 - local.get $sl - local.set $sl|18 - local.get $root|16 - local.get $fl|17 - i32.const 4 - i32.shl - local.get $sl|18 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.1 - end - local.set $head - local.get $block - i32.const 0 - call $~lib/rt/tlsf/Block#set:prev - local.get $block - local.get $head - call $~lib/rt/tlsf/Block#set:next - local.get $head - if - local.get $head - local.get $block - call $~lib/rt/tlsf/Block#set:prev - end - local.get $root - local.set $root|20 - local.get $fl - local.set $fl|21 - local.get $sl - local.set $sl|22 - local.get $block - local.set $head|23 - local.get $root|20 - local.get $fl|21 - i32.const 4 - i32.shl - local.get $sl|22 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head|23 - i32.store offset=96 - local.get $root - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 1 - local.get $fl - i32.shl - i32.or - call $~lib/rt/tlsf/Root#set:flMap - local.get $root - local.set $root|26 - local.get $fl - local.set $fl|27 - block $~lib/rt/tlsf/GETSL|inlined.1 (result i32) - local.get $root - local.set $root|24 - local.get $fl - local.set $fl|25 - local.get $root|24 - local.get $fl|25 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.1 - end - i32.const 1 - local.get $sl - i32.shl - i32.or - local.set $slMap - local.get $root|26 - local.get $fl|27 - i32.const 2 - i32.shl - i32.add - local.get $slMap - i32.store offset=4 - ) - (func $~lib/rt/tlsf/addMemory (param $root i32) (param $start i32) (param $endU64 i64) (result i32) - (local $end i32) - (local $root|4 i32) - (local $tail i32) - (local $tailInfo i32) - (local $size i32) - (local $leftSize i32) - (local $left i32) - (local $root|10 i32) - (local $tail|11 i32) - local.get $endU64 - i32.wrap_i64 - local.set $end - i32.const 1 - drop - local.get $start - i64.extend_i32_u - local.get $endU64 - i64.le_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 382 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $start - i32.const 4 - i32.add - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - i32.const 4 - i32.sub - local.set $start - local.get $end - i32.const 15 - i32.const -1 - i32.xor - i32.and - local.set $end - block $~lib/rt/tlsf/GETTAIL|inlined.0 (result i32) - local.get $root - local.set $root|4 - local.get $root|4 - i32.load offset=1568 - br $~lib/rt/tlsf/GETTAIL|inlined.0 - end - local.set $tail - i32.const 0 - local.set $tailInfo - local.get $tail - if - i32.const 1 - drop - local.get $start - local.get $tail - i32.const 4 - i32.add - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 389 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $start - i32.const 16 - i32.sub - local.get $tail - i32.eq - if - local.get $start - i32.const 16 - i32.sub - local.set $start - local.get $tail - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $tailInfo - else - end - else - i32.const 1 - drop - local.get $start - local.get $root - i32.const 1572 - i32.add - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 402 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - end - local.get $end - local.get $start - i32.sub - local.set $size - local.get $size - i32.const 4 - i32.const 12 - i32.add - i32.const 4 - i32.add - i32.lt_u - if - i32.const 0 - return - end - local.get $size - i32.const 2 - i32.const 4 - i32.mul - i32.sub - local.set $leftSize - local.get $start - local.set $left - local.get $left - local.get $leftSize - i32.const 1 - i32.or - local.get $tailInfo - i32.const 2 - i32.and - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $left - i32.const 0 - call $~lib/rt/tlsf/Block#set:prev - local.get $left - i32.const 0 - call $~lib/rt/tlsf/Block#set:next - local.get $start - i32.const 4 - i32.add - local.get $leftSize - i32.add - local.set $tail - local.get $tail - i32.const 0 - i32.const 2 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.set $root|10 - local.get $tail - local.set $tail|11 - local.get $root|10 - local.get $tail|11 - i32.store offset=1568 - local.get $root - local.get $left - call $~lib/rt/tlsf/insertBlock - i32.const 1 - return - ) - (func $~lib/rt/tlsf/initialize - (local $rootOffset i32) - (local $pagesBefore i32) - (local $pagesNeeded i32) - (local $root i32) - (local $root|4 i32) - (local $tail i32) - (local $fl i32) - (local $root|7 i32) - (local $fl|8 i32) - (local $slMap i32) - (local $sl i32) - (local $root|11 i32) - (local $fl|12 i32) - (local $sl|13 i32) - (local $head i32) - (local $memStart i32) - i32.const 0 - drop - global.get $~lib/memory/__heap_base - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - local.set $rootOffset - memory.size - local.set $pagesBefore - local.get $rootOffset - i32.const 1572 - i32.add - i32.const 65535 - i32.add - i32.const 65535 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.shr_u - local.set $pagesNeeded - local.get $pagesNeeded - local.get $pagesBefore - i32.gt_s - if (result i32) - local.get $pagesNeeded - local.get $pagesBefore - i32.sub - memory.grow - i32.const 0 - i32.lt_s - else - i32.const 0 - end - if - unreachable - end - local.get $rootOffset - local.set $root - local.get $root - i32.const 0 - call $~lib/rt/tlsf/Root#set:flMap - local.get $root - local.set $root|4 - i32.const 0 - local.set $tail - local.get $root|4 - local.get $tail - i32.store offset=1568 - i32.const 0 - local.set $fl - loop $for-loop|0 - local.get $fl - i32.const 23 - i32.lt_u - if - local.get $root - local.set $root|7 - local.get $fl - local.set $fl|8 - i32.const 0 - local.set $slMap - local.get $root|7 - local.get $fl|8 - i32.const 2 - i32.shl - i32.add - local.get $slMap - i32.store offset=4 - i32.const 0 - local.set $sl - loop $for-loop|1 - local.get $sl - i32.const 16 - i32.lt_u - if - local.get $root - local.set $root|11 - local.get $fl - local.set $fl|12 - local.get $sl - local.set $sl|13 - i32.const 0 - local.set $head - local.get $root|11 - local.get $fl|12 - i32.const 4 - i32.shl - local.get $sl|13 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head - i32.store offset=96 - local.get $sl - i32.const 1 - i32.add - local.set $sl - br $for-loop|1 - end - end - local.get $fl - i32.const 1 - i32.add - local.set $fl - br $for-loop|0 - end - end - local.get $rootOffset - i32.const 1572 - i32.add - local.set $memStart - i32.const 0 - drop - local.get $root - local.get $memStart - memory.size - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - drop - local.get $root - global.set $~lib/rt/tlsf/ROOT - ) - (func $~lib/rt/tlsf/checkUsedBlock (param $ptr i32) (result i32) - (local $block i32) - local.get $ptr - i32.const 4 - i32.sub - local.set $block - local.get $ptr - i32.const 0 - i32.ne - if (result i32) - local.get $ptr - i32.const 15 - i32.and - i32.eqz - else - i32.const 0 - end - if (result i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 1 - i32.and - i32.eqz - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 562 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - local.get $block - return - ) - (func $~lib/rt/tlsf/freeBlock (param $root i32) (param $block i32) - i32.const 0 - drop - local.get $block - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 1 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.get $block - call $~lib/rt/tlsf/insertBlock - ) - (func $~lib/rt/tlsf/__free (param $ptr i32) - local.get $ptr - global.get $~lib/memory/__heap_base - i32.lt_u - if - return - end - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $ptr - call $~lib/rt/tlsf/checkUsedBlock - call $~lib/rt/tlsf/freeBlock - ) - (func $~lib/rt/itcms/free (param $obj i32) - local.get $obj - global.get $~lib/memory/__heap_base - i32.lt_u - if - local.get $obj - i32.const 0 - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $obj - i32.const 0 - call $~lib/rt/itcms/Object#set:prev - else - global.get $~lib/rt/itcms/total - local.get $obj - call $~lib/rt/itcms/Object#get:size - i32.sub - global.set $~lib/rt/itcms/total - i32.const 0 - drop - local.get $obj - i32.const 4 - i32.add - call $~lib/rt/tlsf/__free - end - ) - (func $~lib/rt/itcms/step (result i32) - (local $obj i32) - (local $1 i32) - (local $black i32) - (local $from i32) - block $break|0 - block $case2|0 - block $case1|0 - block $case0|0 - global.get $~lib/rt/itcms/state - local.set $1 - local.get $1 - i32.const 0 - i32.eq - br_if $case0|0 - local.get $1 - i32.const 1 - i32.eq - br_if $case1|0 - local.get $1 - i32.const 2 - i32.eq - br_if $case2|0 - br $break|0 - end - i32.const 1 - global.set $~lib/rt/itcms/state - i32.const 0 - global.set $~lib/rt/itcms/visitCount - i32.const 0 - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/iter - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - global.get $~lib/rt/itcms/white - i32.eqz - local.set $black - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - loop $while-continue|1 - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - global.set $~lib/rt/itcms/iter - local.get $obj - call $~lib/rt/itcms/Object#get:color - local.get $black - i32.ne - if - local.get $obj - local.get $black - call $~lib/rt/itcms/Object#set:color - i32.const 0 - global.set $~lib/rt/itcms/visitCount - local.get $obj - i32.const 20 - i32.add - i32.const 0 - call $~lib/rt/__visit_members - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - local.get $obj - call $~lib/rt/itcms/Object#get:next - local.set $obj - br $while-continue|1 - end - end - i32.const 0 - global.set $~lib/rt/itcms/visitCount - i32.const 0 - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.eq - if - i32.const 0 - call $~lib/rt/itcms/visitStack - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - loop $while-continue|2 - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - call $~lib/rt/itcms/Object#get:color - local.get $black - i32.ne - if - local.get $obj - local.get $black - call $~lib/rt/itcms/Object#set:color - local.get $obj - i32.const 20 - i32.add - i32.const 0 - call $~lib/rt/__visit_members - end - local.get $obj - call $~lib/rt/itcms/Object#get:next - local.set $obj - br $while-continue|2 - end - end - global.get $~lib/rt/itcms/fromSpace - local.set $from - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/fromSpace - local.get $from - global.set $~lib/rt/itcms/toSpace - local.get $black - global.set $~lib/rt/itcms/white - local.get $from - call $~lib/rt/itcms/Object#get:next - global.set $~lib/rt/itcms/iter - i32.const 2 - global.set $~lib/rt/itcms/state - end - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - global.get $~lib/rt/itcms/iter - local.set $obj - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - call $~lib/rt/itcms/Object#get:next - global.set $~lib/rt/itcms/iter - i32.const 1 - drop - local.get $obj - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eqz - i32.eq - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 229 - i32.const 20 - call $~lib/builtins/abort - unreachable - end - local.get $obj - call $~lib/rt/itcms/free - i32.const 10 - return - end - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - call $~lib/rt/itcms/Object#set:nextWithColor - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - call $~lib/rt/itcms/Object#set:prev - i32.const 0 - global.set $~lib/rt/itcms/state - br $break|0 - end - i32.const 0 - return - ) - (func $~lib/rt/itcms/interrupt - (local $budget i32) - i32.const 0 - drop - i32.const 0 - drop - i32.const 1024 - i32.const 200 - i32.mul - i32.const 100 - i32.div_u - local.set $budget - loop $do-loop|0 - local.get $budget - call $~lib/rt/itcms/step - i32.sub - local.set $budget - global.get $~lib/rt/itcms/state - i32.const 0 - i32.eq - if - i32.const 0 - drop - global.get $~lib/rt/itcms/total - i64.extend_i32_u - i32.const 200 - i64.extend_i32_u - i64.mul - i64.const 100 - i64.div_u - i32.wrap_i64 - i32.const 1024 - i32.add - global.set $~lib/rt/itcms/threshold - i32.const 0 - drop - return - end - local.get $budget - i32.const 0 - i32.gt_s - br_if $do-loop|0 - end - i32.const 0 - drop - global.get $~lib/rt/itcms/total - i32.const 1024 - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.sub - i32.const 1024 - i32.lt_u - i32.mul - i32.add - global.set $~lib/rt/itcms/threshold - i32.const 0 - drop - ) - (func $~lib/rt/tlsf/computeSize (param $size i32) (result i32) - local.get $size - i32.const 12 - i32.le_u - if (result i32) - i32.const 12 - else - local.get $size - i32.const 4 - i32.add - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - i32.const 4 - i32.sub - end - return - ) - (func $~lib/rt/tlsf/prepareSize (param $size i32) (result i32) - local.get $size - i32.const 1073741820 - i32.gt_u - if - i32.const 288 - i32.const 624 - i32.const 461 - i32.const 29 - call $~lib/builtins/abort - unreachable - end - local.get $size - call $~lib/rt/tlsf/computeSize - return - ) - (func $~lib/rt/tlsf/roundSize (param $size i32) (result i32) - local.get $size - i32.const 536870910 - i32.lt_u - if (result i32) - local.get $size - i32.const 1 - i32.const 27 - local.get $size - i32.clz - i32.sub - i32.shl - i32.add - i32.const 1 - i32.sub - else - local.get $size - end - return - ) - (func $~lib/rt/tlsf/searchBlock (param $root i32) (param $size i32) (result i32) - (local $fl i32) - (local $sl i32) - (local $requestSize i32) - (local $root|5 i32) - (local $fl|6 i32) - (local $slMap i32) - (local $head i32) - (local $flMap i32) - (local $root|10 i32) - (local $fl|11 i32) - (local $root|12 i32) - (local $fl|13 i32) - (local $sl|14 i32) - (local $root|15 i32) - (local $fl|16 i32) - (local $sl|17 i32) - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - call $~lib/rt/tlsf/roundSize - local.set $requestSize - i32.const 4 - i32.const 8 - i32.mul - i32.const 1 - i32.sub - local.get $requestSize - i32.clz - i32.sub - local.set $fl - local.get $requestSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 334 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETSL|inlined.2 (result i32) - local.get $root - local.set $root|5 - local.get $fl - local.set $fl|6 - local.get $root|5 - local.get $fl|6 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.2 - end - i32.const 0 - i32.const -1 - i32.xor - local.get $sl - i32.shl - i32.and - local.set $slMap - i32.const 0 - local.set $head - local.get $slMap - i32.eqz - if - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 0 - i32.const -1 - i32.xor - local.get $fl - i32.const 1 - i32.add - i32.shl - i32.and - local.set $flMap - local.get $flMap - i32.eqz - if - i32.const 0 - local.set $head - else - local.get $flMap - i32.ctz - local.set $fl - block $~lib/rt/tlsf/GETSL|inlined.3 (result i32) - local.get $root - local.set $root|10 - local.get $fl - local.set $fl|11 - local.get $root|10 - local.get $fl|11 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.3 - end - local.set $slMap - i32.const 1 - drop - local.get $slMap - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 347 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETHEAD|inlined.2 (result i32) - local.get $root - local.set $root|12 - local.get $fl - local.set $fl|13 - local.get $slMap - i32.ctz - local.set $sl|14 - local.get $root|12 - local.get $fl|13 - i32.const 4 - i32.shl - local.get $sl|14 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.2 - end - local.set $head - end - else - block $~lib/rt/tlsf/GETHEAD|inlined.3 (result i32) - local.get $root - local.set $root|15 - local.get $fl - local.set $fl|16 - local.get $slMap - i32.ctz - local.set $sl|17 - local.get $root|15 - local.get $fl|16 - i32.const 4 - i32.shl - local.get $sl|17 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.3 - end - local.set $head - end - local.get $head - return - ) - (func $~lib/rt/tlsf/growMemory (param $root i32) (param $size i32) - (local $pagesBefore i32) - (local $root|3 i32) - (local $pagesNeeded i32) - (local $5 i32) - (local $6 i32) - (local $pagesWanted i32) - (local $pagesAfter i32) - i32.const 0 - drop - local.get $size - i32.const 256 - i32.ge_u - if - local.get $size - call $~lib/rt/tlsf/roundSize - local.set $size - end - memory.size - local.set $pagesBefore - local.get $size - i32.const 4 - local.get $pagesBefore - i32.const 16 - i32.shl - i32.const 4 - i32.sub - block $~lib/rt/tlsf/GETTAIL|inlined.1 (result i32) - local.get $root - local.set $root|3 - local.get $root|3 - i32.load offset=1568 - br $~lib/rt/tlsf/GETTAIL|inlined.1 - end - i32.ne - i32.shl - i32.add - local.set $size - local.get $size - i32.const 65535 - i32.add - i32.const 65535 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.shr_u - local.set $pagesNeeded - local.get $pagesBefore - local.tee $5 - local.get $pagesNeeded - local.tee $6 - local.get $5 - local.get $6 - i32.gt_s - select - local.set $pagesWanted - local.get $pagesWanted - memory.grow - i32.const 0 - i32.lt_s - if - local.get $pagesNeeded - memory.grow - i32.const 0 - i32.lt_s - if - unreachable - end - end - memory.size - local.set $pagesAfter - local.get $root - local.get $pagesBefore - i32.const 16 - i32.shl - local.get $pagesAfter - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - drop - ) - (func $~lib/rt/tlsf/prepareBlock (param $root i32) (param $block i32) (param $size i32) - (local $blockInfo i32) - (local $remaining i32) - (local $spare i32) - (local $block|6 i32) - (local $block|7 i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $size - i32.const 4 - i32.add - i32.const 15 - i32.and - i32.eqz - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 361 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $size - i32.sub - local.set $remaining - local.get $remaining - i32.const 4 - i32.const 12 - i32.add - i32.ge_u - if - local.get $block - local.get $size - local.get $blockInfo - i32.const 2 - i32.and - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $block - i32.const 4 - i32.add - local.get $size - i32.add - local.set $spare - local.get $spare - local.get $remaining - i32.const 4 - i32.sub - i32.const 1 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.get $spare - call $~lib/rt/tlsf/insertBlock - else - local.get $block - local.get $blockInfo - i32.const 1 - i32.const -1 - i32.xor - i32.and - call $~lib/rt/common/BLOCK#set:mmInfo - block $~lib/rt/tlsf/GETRIGHT|inlined.3 (result i32) - local.get $block - local.set $block|7 - local.get $block|7 - i32.const 4 - i32.add - local.get $block|7 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.3 - end - block $~lib/rt/tlsf/GETRIGHT|inlined.2 (result i32) - local.get $block - local.set $block|6 - local.get $block|6 - i32.const 4 - i32.add - local.get $block|6 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.2 - end - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 2 - i32.const -1 - i32.xor - i32.and - call $~lib/rt/common/BLOCK#set:mmInfo - end - ) - (func $~lib/rt/tlsf/allocateBlock (param $root i32) (param $size i32) (result i32) - (local $payloadSize i32) - (local $block i32) - local.get $size - call $~lib/rt/tlsf/prepareSize - local.set $payloadSize - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/searchBlock - local.set $block - local.get $block - i32.eqz - if - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/growMemory - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/searchBlock - local.set $block - i32.const 1 - drop - local.get $block - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 499 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - end - i32.const 1 - drop - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $payloadSize - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 501 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $root - local.get $block - call $~lib/rt/tlsf/removeBlock - local.get $root - local.get $block - local.get $payloadSize - call $~lib/rt/tlsf/prepareBlock - i32.const 0 - drop - local.get $block - return - ) - (func $~lib/rt/tlsf/__alloc (param $size i32) (result i32) - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $size - call $~lib/rt/tlsf/allocateBlock - i32.const 4 - i32.add - return - ) - (func $~lib/rt/itcms/Object#set:rtId (param $this i32) (param $rtId i32) - local.get $this - local.get $rtId - i32.store offset=12 - ) - (func $~lib/rt/itcms/Object#set:rtSize (param $this i32) (param $rtSize i32) - local.get $this - local.get $rtSize - i32.store offset=16 - ) - (func $~lib/rt/itcms/__new (param $size i32) (param $id i32) (result i32) - (local $obj i32) - (local $ptr i32) - local.get $size - i32.const 1073741804 - i32.ge_u - if - i32.const 288 - i32.const 352 - i32.const 261 - i32.const 31 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.ge_u - if - call $~lib/rt/itcms/interrupt - end - i32.const 16 - local.get $size - i32.add - call $~lib/rt/tlsf/__alloc - i32.const 4 - i32.sub - local.set $obj - local.get $obj - local.get $id - call $~lib/rt/itcms/Object#set:rtId - local.get $obj - local.get $size - call $~lib/rt/itcms/Object#set:rtSize - local.get $obj - global.get $~lib/rt/itcms/fromSpace - global.get $~lib/rt/itcms/white - call $~lib/rt/itcms/Object#linkTo - global.get $~lib/rt/itcms/total - local.get $obj - call $~lib/rt/itcms/Object#get:size - i32.add - global.set $~lib/rt/itcms/total - local.get $obj - i32.const 20 - i32.add - local.set $ptr - local.get $ptr - i32.const 0 - local.get $size - memory.fill - local.get $ptr - return - ) - (func $assembly/arguments/Args#set:a (param $this i32) (param $a i32) - local.get $this - local.get $a - i32.store - ) - (func $assembly/arguments/Args#set:b (param $this i32) (param $b i32) - local.get $this - local.get $b - i32.store offset=4 - ) - (func $assembly/arguments/Args#set:c (param $this i32) (param $c i32) - local.get $this - local.get $c - i32.store offset=8 - ) - (func $assembly/arguments/Args#set:d (param $this i32) (param $d i32) - local.get $this - local.get $d - i32.store offset=12 - ) - (func $start:assembly/arguments~anonymous|0 (param $_d i32) (param $_l i32) (result i32) - i32.const 0 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - return - ) - (func $~lib/arraybuffer/ArrayBufferView#get:byteLength (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/arraybuffer/ArrayBufferView#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/itcms/__link (param $parentPtr i32) (param $childPtr i32) (param $expectMultiple i32) - (local $child i32) - (local $parent i32) - (local $parentColor i32) - local.get $childPtr - i32.eqz - if - return - end - i32.const 1 - drop - local.get $parentPtr - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 295 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $childPtr - i32.const 20 - i32.sub - local.set $child - local.get $child - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eq - if - local.get $parentPtr - i32.const 20 - i32.sub - local.set $parent - local.get $parent - call $~lib/rt/itcms/Object#get:color - local.set $parentColor - local.get $parentColor - global.get $~lib/rt/itcms/white - i32.eqz - i32.eq - if - local.get $expectMultiple - if - local.get $parent - call $~lib/rt/itcms/Object#makeGray - else - local.get $child - call $~lib/rt/itcms/Object#makeGray - end - else - local.get $parentColor - i32.const 3 - i32.eq - if (result i32) - global.get $~lib/rt/itcms/state - i32.const 1 - i32.eq - else - i32.const 0 - end - if - local.get $child - call $~lib/rt/itcms/Object#makeGray - end - end - end - ) - (func $~lib/arraybuffer/ArrayBufferView#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/arguments/Nibbles#set:low (param $this i32) (param $low i32) - local.get $this - local.get $low - i32.store8 - ) - (func $assembly/arguments/Nibbles#set:hig (param $this i32) (param $hig i32) - local.get $this - local.get $hig - i32.store8 offset=1 - ) - (func $assembly/arguments/Nibbles#get:low (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $assembly/arguments/Nibbles#get:hig (param $this i32) (result i32) - local.get $this - i32.load8_u offset=1 - ) - (func $assembly/arguments/Args#get:a (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/arguments/Args#get:b (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $start:assembly/arguments - (local $0 i32) - (local $1 i32) - (local $2 i32) - memory.size - i32.const 16 - i32.shl - global.get $~lib/memory/__heap_base - i32.sub - i32.const 1 - i32.shr_u - global.set $~lib/rt/itcms/threshold - i32.const 400 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/pinSpace - i32.const 432 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/toSpace - i32.const 576 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/fromSpace - ) - (func $assembly/instructions/Instruction#set:namePtr (param $this i32) (param $namePtr i32) - local.get $this - local.get $namePtr - i32.store - ) - (func $assembly/instructions/Instruction#set:kind (param $this i32) (param $kind i32) - local.get $this - local.get $kind - i32.store offset=4 - ) - (func $assembly/instructions/Instruction#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/instructions/Instruction#set:isTerminating (param $this i32) (param $isTerminating i32) - local.get $this - local.get $isTerminating - i32.store8 offset=16 - ) - (func $assembly/instructions/Instruction#constructor (param $this i32) (result i32) - local.get $this - i32.eqz - if - i32.const 17 - call $~lib/rt/tlsf/__alloc - local.set $this - end - local.get $this - i32.const 0 - call $assembly/instructions/Instruction#set:namePtr - local.get $this - global.get $assembly/arguments/Arguments.Zero - call $assembly/instructions/Instruction#set:kind - local.get $this - i64.const 0 - call $assembly/instructions/Instruction#set:gas - local.get $this - i32.const 0 - call $assembly/instructions/Instruction#set:isTerminating - local.get $this - ) - (func $assembly/instructions/instruction (param $name i32) (param $kind i32) (param $gas i64) (param $isTerminating i32) (result i32) - (local $i i32) - i32.const 0 - call $assembly/instructions/Instruction#constructor - local.set $i - local.get $i - local.get $name - call $assembly/instructions/Instruction#set:namePtr - local.get $i - local.get $kind - call $assembly/instructions/Instruction#set:kind - local.get $i - local.get $gas - call $assembly/instructions/Instruction#set:gas - local.get $i - local.get $isTerminating - call $assembly/instructions/Instruction#set:isTerminating - local.get $i - return - ) - (func $~lib/rt/__newBuffer (param $size i32) (param $id i32) (param $data i32) (result i32) - (local $buffer i32) - local.get $size - local.get $id - call $~lib/rt/itcms/__new - local.set $buffer - local.get $data - if - local.get $buffer - local.get $data - local.get $size - memory.copy - end - local.get $buffer - return - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/rt/itcms/Object#get:rtSize (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $~lib/rt/itcms/__renew (param $oldPtr i32) (param $size i32) (result i32) - (local $oldObj i32) - (local $newPtr i32) - (local $4 i32) - (local $5 i32) - local.get $oldPtr - i32.const 20 - i32.sub - local.set $oldObj - local.get $size - local.get $oldObj - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.sub - i32.le_u - if - local.get $oldObj - local.get $size - call $~lib/rt/itcms/Object#set:rtSize - local.get $oldPtr - return - end - local.get $size - local.get $oldObj - call $~lib/rt/itcms/Object#get:rtId - call $~lib/rt/itcms/__new - local.set $newPtr - local.get $newPtr - local.get $oldPtr - local.get $size - local.tee $4 - local.get $oldObj - call $~lib/rt/itcms/Object#get:rtSize - local.tee $5 - local.get $4 - local.get $5 - i32.lt_u - select - memory.copy - local.get $newPtr - return - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/math/ipow32 (param $x i32) (param $e i32) (result i32) - (local $out i32) - (local $log i32) - (local $4 i32) - i32.const 1 - local.set $out - i32.const 0 - i32.const 1 - i32.lt_s - drop - local.get $x - i32.const 2 - i32.eq - if - i32.const 1 - local.get $e - i32.shl - i32.const 0 - local.get $e - i32.const 32 - i32.lt_u - select - return - end - local.get $e - i32.const 0 - i32.le_s - if - local.get $x - i32.const -1 - i32.eq - if - i32.const -1 - i32.const 1 - local.get $e - i32.const 1 - i32.and - select - return - end - local.get $e - i32.const 0 - i32.eq - local.get $x - i32.const 1 - i32.eq - i32.or - return - else - local.get $e - i32.const 1 - i32.eq - if - local.get $x - return - else - local.get $e - i32.const 2 - i32.eq - if - local.get $x - local.get $x - i32.mul - return - else - local.get $e - i32.const 32 - i32.lt_s - if - i32.const 32 - local.get $e - i32.clz - i32.sub - local.set $log - block $break|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $log - local.set $4 - local.get $4 - i32.const 5 - i32.eq - br_if $case0|0 - local.get $4 - i32.const 4 - i32.eq - br_if $case1|0 - local.get $4 - i32.const 3 - i32.eq - br_if $case2|0 - local.get $4 - i32.const 2 - i32.eq - br_if $case3|0 - local.get $4 - i32.const 1 - i32.eq - br_if $case4|0 - br $break|0 - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - end - local.get $out - return - end - end - end - end - loop $while-continue|1 - local.get $e - if - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - br $while-continue|1 - end - end - local.get $out - return - ) - (func $start:assembly/memory-page - i32.const 2 - i32.const 12 - call $~lib/math/ipow32 - global.set $assembly/memory-page/PAGE_SIZE - i32.const 2 - i32.const 16 - call $~lib/math/ipow32 - global.set $assembly/memory-page/SEGMENT_SIZE - i32.const 2 - i32.const 16 - call $~lib/math/ipow32 - global.set $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/PAGE_SIZE - i32.div_u - global.set $assembly/memory-page/RESERVED_PAGES - i32.const 2 - i32.const 29 - call $~lib/math/ipow32 - global.set $assembly/memory-page/ALLOCATE_EAGERLY - ) - (func $assembly/memory/MaybePageFault#set:isFault (param $this i32) (param $isFault i32) - local.get $this - local.get $isFault - i32.store8 - ) - (func $assembly/memory/MaybePageFault#set:isAccess (param $this i32) (param $isAccess i32) - local.get $this - local.get $isAccess - i32.store8 offset=1 - ) - (func $assembly/memory/MaybePageFault#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store offset=4 - ) - (func $~lib/arraybuffer/ArrayBufferView#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/arraybuffer/ArrayBufferView#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/arraybuffer/ArrayBufferView#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $assembly/memory-page/Page#set:access (param $this i32) (param $access i32) - local.get $this - local.get $access - i32.store - ) - (func $assembly/memory-page/Page#set:raw (param $this i32) (param $raw i32) - local.get $this - local.get $raw - i32.store offset=4 - local.get $this - local.get $raw - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/RawPage#set:id (param $this i32) (param $id i32) - local.get $this - local.get $id - i32.store - ) - (func $assembly/memory-page/RawPage#set:page (param $this i32) (param $page i32) - local.get $this - local.get $page - i32.store offset=4 - local.get $this - local.get $page - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $start:assembly/instructions/outcome - call $start:assembly/memory - ) - (func $assembly/instructions/utils/reg (param $v i64) (result i32) - local.get $v - global.get $assembly/registers/NO_OF_REGISTERS - i64.extend_i32_s - i64.ge_u - if (result i32) - global.get $assembly/registers/NO_OF_REGISTERS - i32.const 1 - i32.sub - else - local.get $v - i32.wrap_i64 - end - return - ) - (func $~lib/rt/common/OBJECT#get:rtSize (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 3 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i64) - local.get $this - local.get $index - i32.const 3 - i32.shl - i32.add - local.get $value - i64.store - i32.const 0 - drop - ) - (func $assembly/instructions/outcome/OutcomeData#set:outcome (param $this i32) (param $outcome i32) - local.get $this - local.get $outcome - i32.store - ) - (func $assembly/instructions/outcome/OutcomeData#set:staticJump (param $this i32) (param $staticJump i32) - local.get $this - local.get $staticJump - i32.store offset=4 - ) - (func $assembly/instructions/outcome/OutcomeData#set:dJump (param $this i32) (param $dJump i32) - local.get $this - local.get $dJump - i32.store offset=8 - ) - (func $assembly/instructions/outcome/OutcomeData#set:result (param $this i32) (param $result i32) - local.get $this - local.get $result - i32.store offset=12 - ) - (func $assembly/instructions/outcome/OutcomeData#set:exitCode (param $this i32) (param $exitCode i32) - local.get $this - local.get $exitCode - i32.store offset=16 - ) - (func $assembly/instructions/outcome/ok (result i32) - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - return - ) - (func $assembly/instructions/utils/u8SignExtend (param $v i32) (result i64) - local.get $v - i32.extend8_s - i64.extend_i32_s - return - ) - (func $assembly/instructions/utils/u16SignExtend (param $v i32) (result i64) - local.get $v - i32.extend16_s - i64.extend_i32_s - return - ) - (func $~lib/polyfills/bswap (param $value i64) (result i64) - (local $a i64) - (local $b i64) - (local $v i64) - i32.const 1 - drop - i32.const 8 - i32.const 1 - i32.eq - drop - i32.const 8 - i32.const 2 - i32.eq - drop - i32.const 8 - i32.const 4 - i32.eq - drop - i32.const 8 - i32.const 8 - i32.eq - drop - local.get $value - i64.const 8 - i64.shr_u - i64.const 71777214294589695 - i64.and - local.set $a - local.get $value - i64.const 71777214294589695 - i64.and - i64.const 8 - i64.shl - local.set $b - local.get $a - local.get $b - i64.or - local.set $v - local.get $v - i64.const 16 - i64.shr_u - i64.const 281470681808895 - i64.and - local.set $a - local.get $v - i64.const 281470681808895 - i64.and - i64.const 16 - i64.shl - local.set $b - local.get $a - local.get $b - i64.or - i64.const 32 - i64.rotr - return - ) - (func $assembly/instructions/utils/u32SignExtend (param $v i32) (result i64) - local.get $v - i64.extend_i32_s - return - ) - (func $assembly/arguments/Args#get:c (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/arguments/Args#get:d (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/memory/Chunks#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#set:first (param $this i32) (param $first i32) - local.get $this - local.get $first - i32.store offset=4 - local.get $this - local.get $first - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#set:second (param $this i32) (param $second i32) - local.get $this - local.get $second - i32.store offset=8 - local.get $this - local.get $second - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#get:pages (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/util/hash/HASH (param $key i32) (result i32) - (local $key|1 i32) - (local $len i32) - (local $h i32) - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 4 - i32.const 4 - i32.le_u - drop - block $~lib/util/hash/hash32|inlined.0 (result i32) - local.get $key - local.set $key|1 - i32.const 4 - local.set $len - i32.const 0 - i32.const 374761393 - i32.add - local.get $len - i32.add - local.set $h - local.get $h - local.get $key|1 - i32.const -1028477379 - i32.mul - i32.add - local.set $h - local.get $h - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 15 - i32.shr_u - i32.xor - local.set $h - local.get $h - i32.const -2048144777 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 13 - i32.shr_u - i32.xor - local.set $h - local.get $h - i32.const -1028477379 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 16 - i32.shr_u - i32.xor - local.set $h - local.get $h - br $~lib/util/hash/hash32|inlined.0 - end - return - ) - (func $"~lib/map/Map#get:buckets" (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $"~lib/map/Map#get:bucketsMask" (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $"~lib/map/MapEntry#get:taggedNext" (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#get:key" (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/PageData#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/PageData#set:page (param $this i32) (param $page i32) - local.get $this - local.get $page - i32.store offset=4 - local.get $this - local.get $page - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/PageData#set:relativeAddress (param $this i32) (param $relativeAddress i32) - local.get $this - local.get $relativeAddress - i32.store offset=8 - ) - (func $"~lib/map/MapEntry#get:value" (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Page#get:access (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/PageData#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/MaybePageFault#get:isFault (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $assembly/memory/PageData#get:page (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/PageData#get:relativeAddress (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/memory-page/Page#get:raw (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/RawPage#get:page (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i32) (param $start i32) (param $end i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $start - i32.add - local.tee $5 - i32.const 0 - local.tee $6 - local.get $5 - local.get $6 - i32.gt_u - select - else - local.get $start - local.tee $7 - local.get $len - local.tee $8 - local.get $7 - local.get $8 - i32.lt_s - select - end - local.set $start - local.get $end - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $end - i32.add - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_u - select - else - local.get $end - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - end - local.set $end - i32.const 1 - i32.const 1 - i32.eq - drop - local.get $start - local.get $end - i32.lt_s - if - local.get $ptr - local.get $start - i32.add - local.get $value - local.get $end - local.get $start - i32.sub - memory.fill - end - ) - (func $assembly/memory/Chunks#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/ChunkBytes#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/ChunkBytes#set:bytes (param $this i32) (param $bytes i32) - local.get $this - local.get $bytes - i32.store offset=4 - local.get $this - local.get $bytes - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#get:first (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/Chunks#get:second (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 0 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - i32.const 0 - drop - ) - (func $assembly/memory/Result#set:ok (param $this i32) (param $ok i64) - local.get $this - local.get $ok - i64.store - ) - (func $assembly/memory/Result#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store offset=8 - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/ChunkBytes#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/ChunkBytes#get:bytes (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/Result#get:fault (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/memory/Result#get:ok (param $this i32) (result i64) - local.get $this - i64.load - ) - (func $assembly/memory/MaybePageFault#get:isAccess (param $this i32) (result i32) - local.get $this - i32.load8_u offset=1 - ) - (func $assembly/memory/MaybePageFault#get:fault (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/math/ipow64 (param $x i64) (param $e i64) (result i64) - (local $out i64) - (local $log i32) - (local $4 i32) - i64.const 1 - local.set $out - i32.const 0 - i32.const 1 - i32.lt_s - drop - local.get $x - i64.const 2 - i64.eq - if - i64.const 1 - local.get $e - i64.shl - i64.const 0 - local.get $e - i64.const 64 - i64.lt_u - select - return - end - local.get $e - i64.const 0 - i64.le_s - if - local.get $x - i64.const -1 - i64.eq - if - i64.const -1 - i64.const 1 - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - select - return - end - local.get $e - i64.const 0 - i64.eq - i64.extend_i32_u - local.get $x - i64.const 1 - i64.eq - i64.extend_i32_u - i64.or - return - else - local.get $e - i64.const 1 - i64.eq - if - local.get $x - return - else - local.get $e - i64.const 2 - i64.eq - if - local.get $x - local.get $x - i64.mul - return - else - local.get $e - i64.const 64 - i64.lt_s - if - i32.const 64 - local.get $e - i64.clz - i32.wrap_i64 - i32.sub - local.set $log - block $break|0 - block $case5|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $log - local.set $4 - local.get $4 - i32.const 6 - i32.eq - br_if $case0|0 - local.get $4 - i32.const 5 - i32.eq - br_if $case1|0 - local.get $4 - i32.const 4 - i32.eq - br_if $case2|0 - local.get $4 - i32.const 3 - i32.eq - br_if $case3|0 - local.get $4 - i32.const 2 - i32.eq - br_if $case4|0 - local.get $4 - i32.const 1 - i32.eq - br_if $case5|0 - br $break|0 - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - end - local.get $out - return - end - end - end - end - loop $while-continue|1 - local.get $e - i64.const 0 - i64.ne - if - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - br $while-continue|1 - end - end - local.get $out - return - ) - (func $assembly/instructions/utils/mulUpperUnsigned (param $a i64) (param $b i64) (result i64) - (local $aHigh i64) - (local $aLow i64) - (local $bHigh i64) - (local $bLow i64) - (local $lowLow i64) - (local $lowHigh i64) - (local $highLow i64) - (local $highHigh i64) - (local $carry i64) - local.get $a - i64.const 32 - i64.shr_u - local.set $aHigh - local.get $a - i64.const 4294967295 - i64.and - local.set $aLow - local.get $b - i64.const 32 - i64.shr_u - local.set $bHigh - local.get $b - i64.const 4294967295 - i64.and - local.set $bLow - local.get $aLow - local.get $bLow - i64.mul - local.set $lowLow - local.get $aLow - local.get $bHigh - i64.mul - local.set $lowHigh - local.get $aHigh - local.get $bLow - i64.mul - local.set $highLow - local.get $aHigh - local.get $bHigh - i64.mul - local.set $highHigh - local.get $lowLow - i64.const 32 - i64.shr_u - local.get $lowHigh - i64.const 4294967295 - i64.and - i64.add - local.get $highLow - i64.const 4294967295 - i64.and - i64.add - local.set $carry - local.get $highHigh - local.get $lowHigh - i64.const 32 - i64.shr_u - i64.add - local.get $highLow - i64.const 32 - i64.shr_u - i64.add - local.get $carry - i64.const 32 - i64.shr_u - i64.add - return - ) - (func $assembly/instructions/utils/mulUpperSigned (param $a i64) (param $b i64) (result i64) - (local $isResultNegative i32) - (local $aAbs i64) - (local $bAbs i64) - (local $upper i64) - (local $lower i64) - i32.const 0 - local.set $isResultNegative - local.get $a - local.set $aAbs - local.get $b - local.set $bAbs - local.get $a - i64.const 0 - i64.lt_s - if - local.get $isResultNegative - i32.eqz - local.set $isResultNegative - local.get $a - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $aAbs - end - local.get $b - i64.const 0 - i64.lt_s - if - local.get $isResultNegative - i32.eqz - local.set $isResultNegative - local.get $b - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $bAbs - end - local.get $isResultNegative - if - local.get $aAbs - local.get $bAbs - call $assembly/instructions/utils/mulUpperUnsigned - local.set $upper - local.get $aAbs - local.get $bAbs - i64.mul - local.set $lower - local.get $upper - i64.const -1 - i64.xor - local.get $lower - i64.const 0 - i64.eq - if (result i64) - i64.const 1 - else - i64.const 0 - end - i64.add - return - end - local.get $aAbs - local.get $bAbs - call $assembly/instructions/utils/mulUpperUnsigned - return - ) - (func $assembly/instructions/utils/mulUpperSignedUnsigned (param $a i64) (param $b i64) (result i64) - (local $aAbs i64) - (local $upper i64) - (local $lower i64) - local.get $a - i64.const 0 - i64.lt_s - if - local.get $a - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $aAbs - local.get $aAbs - local.get $b - call $assembly/instructions/utils/mulUpperUnsigned - local.set $upper - local.get $aAbs - local.get $b - i64.mul - local.set $lower - local.get $upper - i64.const -1 - i64.xor - local.get $lower - i64.const 0 - i64.eq - if (result i64) - i64.const 1 - else - i64.const 0 - end - i64.add - return - end - local.get $a - local.get $b - call $assembly/instructions/utils/mulUpperUnsigned - return - ) - (func $assembly/instructions/outcome/panic (result i32) - global.get $assembly/instructions/outcome/Result.PANIC - call $assembly/instructions/outcome/status - return - ) - (func $start:assembly/instructions/misc~anonymous|0 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/panic - ) - (func $start:assembly/instructions/misc~anonymous|1 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/panic - ) - (func $start:assembly/instructions/misc~anonymous|2 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/ok - ) - (func $assembly/memory/Memory#get:sbrkAddress (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/memory/Memory#set:sbrkAddress (param $this i32) (param $sbrkAddress i32) - local.get $this - local.get $sbrkAddress - i32.store offset=12 - ) - (func $assembly/memory/Memory#get:lastAllocatedPage (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/Memory#get:arena (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Arena#get:free (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $assembly/memory-page/Arena#get:extraPageIndex (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/memory-page/Arena#get:arenaBytes (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Arena#set:extraPageIndex (param $this i32) (param $extraPageIndex i32) - local.get $this - local.get $extraPageIndex - i32.store offset=8 - ) - (func $"~lib/map/MapEntry#set:value" (param $this i32) (param $value i32) - local.get $this - local.get $value - i32.store offset=4 - ) - (func $"~lib/map/Map#get:entriesOffset" (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $"~lib/map/Map#get:entriesCapacity" (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $"~lib/map/Map#get:entriesCount" (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $"~lib/map/Map#get:entries" (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#set:key" (param $this i32) (param $key i32) - local.get $this - local.get $key - i32.store - ) - (func $"~lib/map/MapEntry#set:taggedNext" (param $this i32) (param $taggedNext i32) - local.get $this - local.get $taggedNext - i32.store offset=8 - ) - (func $"~lib/map/Map#set:buckets" (param $this i32) (param $buckets i32) - local.get $this - local.get $buckets - i32.store - local.get $this - local.get $buckets - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $"~lib/map/Map#set:bucketsMask" (param $this i32) (param $bucketsMask i32) - local.get $this - local.get $bucketsMask - i32.store offset=4 - ) - (func $"~lib/map/Map#set:entries" (param $this i32) (param $entries i32) - local.get $this - local.get $entries - i32.store offset=8 - local.get $this - local.get $entries - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $"~lib/map/Map#set:entriesCapacity" (param $this i32) (param $entriesCapacity i32) - local.get $this - local.get $entriesCapacity - i32.store offset=12 - ) - (func $"~lib/map/Map#set:entriesOffset" (param $this i32) (param $entriesOffset i32) - local.get $this - local.get $entriesOffset - i32.store offset=16 - ) - (func $"~lib/map/Map#set:entriesCount" (param $this i32) (param $entriesCount i32) - local.get $this - local.get $entriesCount - i32.store offset=20 - ) - (func $assembly/memory/Memory#set:lastAllocatedPage (param $this i32) (param $lastAllocatedPage i32) - local.get $this - local.get $lastAllocatedPage - i32.store - ) - (func $assembly/instructions/rot/math.rot_r (param $v i64) (param $shift i64) (result i64) - local.get $v - local.get $shift - i64.rotr - return - ) - (func $assembly/instructions/rot/math.rot_r_32 (param $v i32) (param $shift i32) (result i32) - local.get $v - local.get $shift - i32.rotr - return - ) - (func $assembly/instructions/rot/math.rot_l (param $v i64) (param $shift i64) (result i64) - local.get $v - local.get $shift - i64.rotl - return - ) - (func $assembly/instructions/rot/math.rot_l_32 (param $v i32) (param $shift i32) (result i32) - local.get $v - local.get $shift - i32.rotl - return - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $start:assembly/interpreter - call $start:assembly/instructions/outcome - i64.const 2 - i64.const 32 - call $~lib/math/ipow64 - global.set $assembly/interpreter/MAX_U32 - ) - (func $start:assembly/api-internal - call $start:assembly/arguments - call $start:assembly/instructions - call $start:assembly/interpreter - ) - (func $start:assembly/spi - i32.const 2 - i32.const 24 - call $~lib/math/ipow32 - global.set $assembly/spi/MAX_ARGS_LEN - i32.const 2 - i32.const 32 - call $~lib/math/ipow32 - global.get $assembly/memory-page/SEGMENT_SIZE - i32.sub - global.get $assembly/spi/MAX_ARGS_LEN - i32.sub - global.set $assembly/spi/ARGS_SEGMENT_START - global.get $assembly/spi/ARGS_SEGMENT_START - global.get $assembly/memory-page/SEGMENT_SIZE - i32.sub - global.set $assembly/spi/STACK_SEGMENT_END - ) - (func $start:assembly/api-debugger - call $start:assembly/api-internal - call $start:assembly/spi - ) - (func $start:assembly/index - call $start:assembly/api-debugger - ) - (func $assembly/program/Program#get:code (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/Program#get:mask (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/program/Mask#get:bytesToSkip (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/string/String#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 1 - i32.shr_u - return - ) - (func $~lib/util/number/decimalCount32 (param $value i32) (result i32) - local.get $value - i32.const 100000 - i32.lt_u - if - local.get $value - i32.const 100 - i32.lt_u - if - i32.const 1 - local.get $value - i32.const 10 - i32.ge_u - i32.add - return - else - i32.const 3 - local.get $value - i32.const 10000 - i32.ge_u - i32.add - local.get $value - i32.const 1000 - i32.ge_u - i32.add - return - end - unreachable - else - local.get $value - i32.const 10000000 - i32.lt_u - if - i32.const 6 - local.get $value - i32.const 1000000 - i32.ge_u - i32.add - return - else - i32.const 8 - local.get $value - i32.const 1000000000 - i32.ge_u - i32.add - local.get $value - i32.const 100000000 - i32.ge_u - i32.add - return - end - unreachable - end - unreachable - ) - (func $~lib/util/number/utoa32_dec_lut (param $buffer i32) (param $num i32) (param $offset i32) - (local $t i32) - (local $r i32) - (local $d1 i32) - (local $d2 i32) - (local $digits1 i64) - (local $digits2 i64) - (local $t|9 i32) - (local $d1|10 i32) - (local $digits i32) - (local $digits|12 i32) - (local $digit i32) - loop $while-continue|0 - local.get $num - i32.const 10000 - i32.ge_u - if - local.get $num - i32.const 10000 - i32.div_u - local.set $t - local.get $num - i32.const 10000 - i32.rem_u - local.set $r - local.get $t - local.set $num - local.get $r - i32.const 100 - i32.div_u - local.set $d1 - local.get $r - i32.const 100 - i32.rem_u - local.set $d2 - i32.const 15068 - local.get $d1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 15068 - local.get $d2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $num - i32.const 100 - i32.ge_u - if - local.get $num - i32.const 100 - i32.div_u - local.set $t|9 - local.get $num - i32.const 100 - i32.rem_u - local.set $d1|10 - local.get $t|9 - local.set $num - local.get $offset - i32.const 2 - i32.sub - local.set $offset - i32.const 15068 - local.get $d1|10 - i32.const 2 - i32.shl - i32.add - i32.load - local.set $digits - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits - i32.store - end - local.get $num - i32.const 10 - i32.ge_u - if - local.get $offset - i32.const 2 - i32.sub - local.set $offset - i32.const 15068 - local.get $num - i32.const 2 - i32.shl - i32.add - i32.load - local.set $digits|12 - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits|12 - i32.store - else - local.get $offset - i32.const 1 - i32.sub - local.set $offset - i32.const 48 - local.get $num - i32.add - local.set $digit - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digit - i32.store16 - end - ) - (func $~lib/util/number/utoa_hex_lut (param $buffer i32) (param $num i64) (param $offset i32) - loop $while-continue|0 - local.get $offset - i32.const 2 - i32.ge_u - if - local.get $offset - i32.const 2 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 15488 - local.get $num - i32.wrap_i64 - i32.const 255 - i32.and - i32.const 2 - i32.shl - i32.add - i32.load - i32.store - local.get $num - i64.const 8 - i64.shr_u - local.set $num - br $while-continue|0 - end - end - local.get $offset - i32.const 1 - i32.and - if - local.get $buffer - i32.const 15488 - local.get $num - i32.wrap_i64 - i32.const 6 - i32.shl - i32.add - i32.load16_u - i32.store16 - end - ) - (func $~lib/util/number/ulog_base (param $num i64) (param $base i32) (result i32) - (local $value i32) - (local $b64 i64) - (local $b i64) - (local $e i32) - block $~lib/util/number/isPowerOf2|inlined.0 (result i32) - local.get $base - local.set $value - local.get $value - i32.popcnt - i32.const 1 - i32.eq - br $~lib/util/number/isPowerOf2|inlined.0 - end - if - i32.const 63 - local.get $num - i64.clz - i32.wrap_i64 - i32.sub - i32.const 31 - local.get $base - i32.clz - i32.sub - i32.div_u - i32.const 1 - i32.add - return - end - local.get $base - i64.extend_i32_s - local.set $b64 - local.get $b64 - local.set $b - i32.const 1 - local.set $e - loop $while-continue|0 - local.get $num - local.get $b - i64.ge_u - if - local.get $num - local.get $b - i64.div_u - local.set $num - local.get $b - local.get $b - i64.mul - local.set $b - local.get $e - i32.const 1 - i32.shl - local.set $e - br $while-continue|0 - end - end - loop $while-continue|1 - local.get $num - i64.const 1 - i64.ge_u - if - local.get $num - local.get $b64 - i64.div_u - local.set $num - local.get $e - i32.const 1 - i32.add - local.set $e - br $while-continue|1 - end - end - local.get $e - i32.const 1 - i32.sub - return - ) - (func $~lib/util/number/utoa64_any_core (param $buffer i32) (param $num i64) (param $offset i32) (param $radix i32) - (local $base i64) - (local $shift i64) - (local $mask i64) - (local $q i64) - local.get $radix - i64.extend_i32_s - local.set $base - local.get $radix - local.get $radix - i32.const 1 - i32.sub - i32.and - i32.const 0 - i32.eq - if - local.get $radix - i32.ctz - i32.const 7 - i32.and - i64.extend_i32_s - local.set $shift - local.get $base - i64.const 1 - i64.sub - local.set $mask - loop $do-loop|0 - local.get $offset - i32.const 1 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 16544 - local.get $num - local.get $mask - i64.and - i32.wrap_i64 - i32.const 1 - i32.shl - i32.add - i32.load16_u - i32.store16 - local.get $num - local.get $shift - i64.shr_u - local.set $num - local.get $num - i64.const 0 - i64.ne - br_if $do-loop|0 - end - else - loop $do-loop|1 - local.get $offset - i32.const 1 - i32.sub - local.set $offset - local.get $num - local.get $base - i64.div_u - local.set $q - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 16544 - local.get $num - local.get $q - local.get $base - i64.mul - i64.sub - i32.wrap_i64 - i32.const 1 - i32.shl - i32.add - i32.load16_u - i32.store16 - local.get $q - local.set $num - local.get $num - i64.const 0 - i64.ne - br_if $do-loop|1 - end - end - ) - (func $~lib/number/I32#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/itoa32 - return - ) - (func $assembly/instructions/Instruction#get:namePtr (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/number/U8#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - i32.const 255 - i32.and - local.get $radix - call $~lib/util/number/utoa32 - return - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $assembly/instructions/Instruction#get:kind (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/number/U32#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/utoa32 - return - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 0 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - i32.const 0 - drop - ) - (func $assembly/program-build/immBytes (param $dataLength i32) (param $required i32) (result i32) - (local $value1 f64) - (local $value2 f64) - local.get $dataLength - local.get $required - i32.lt_s - if - i32.const 0 - return - end - block $~lib/math/NativeMath.min|inlined.4 (result f64) - f64.const 4 - local.set $value1 - local.get $dataLength - local.get $required - i32.sub - f64.convert_i32_s - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.4 - end - i32.trunc_sat_f64_s - return - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/arraybuffer/ArrayBuffer#get:byteLength (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - return - ) - (func $~lib/dataview/DataView#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/dataview/DataView#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/dataview/DataView#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $~lib/dataview/DataView#get:byteLength (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/dataview/DataView#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/util/number/decimalCount64High (param $value i64) (result i32) - local.get $value - i64.const 1000000000000000 - i64.lt_u - if - local.get $value - i64.const 1000000000000 - i64.lt_u - if - i32.const 10 - local.get $value - i64.const 100000000000 - i64.ge_u - i32.add - local.get $value - i64.const 10000000000 - i64.ge_u - i32.add - return - else - i32.const 13 - local.get $value - i64.const 100000000000000 - i64.ge_u - i32.add - local.get $value - i64.const 10000000000000 - i64.ge_u - i32.add - return - end - unreachable - else - local.get $value - i64.const 100000000000000000 - i64.lt_u - if - i32.const 16 - local.get $value - i64.const 10000000000000000 - i64.ge_u - i32.add - return - else - i32.const 18 - local.get $value - i64.const -8446744073709551616 - i64.ge_u - i32.add - local.get $value - i64.const 1000000000000000000 - i64.ge_u - i32.add - return - end - unreachable - end - unreachable - ) - (func $~lib/util/number/utoa64_dec_lut (param $buffer i32) (param $num i64) (param $offset i32) - (local $t i64) - (local $r i32) - (local $b i32) - (local $c i32) - (local $b1 i32) - (local $b2 i32) - (local $c1 i32) - (local $c2 i32) - (local $digits1 i64) - (local $digits2 i64) - loop $while-continue|0 - local.get $num - i64.const 100000000 - i64.ge_u - if - local.get $num - i64.const 100000000 - i64.div_u - local.set $t - local.get $num - local.get $t - i64.const 100000000 - i64.mul - i64.sub - i32.wrap_i64 - local.set $r - local.get $t - local.set $num - local.get $r - i32.const 10000 - i32.div_u - local.set $b - local.get $r - i32.const 10000 - i32.rem_u - local.set $c - local.get $b - i32.const 100 - i32.div_u - local.set $b1 - local.get $b - i32.const 100 - i32.rem_u - local.set $b2 - local.get $c - i32.const 100 - i32.div_u - local.set $c1 - local.get $c - i32.const 100 - i32.rem_u - local.set $c2 - i32.const 15068 - local.get $c1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 15068 - local.get $c2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - i32.const 15068 - local.get $b1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 15068 - local.get $b2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $buffer - local.get $num - i32.wrap_i64 - local.get $offset - call $~lib/util/number/utoa32_dec_lut - ) - (func $~lib/number/U64#toString (param $this i64) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/utoa64 - return - ) - (func $assembly/codec/Decoder#set:source (param $this i32) (param $source i32) - local.get $this - local.get $source - i32.store - local.get $this - local.get $source - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/codec/Decoder#set:offset (param $this i32) (param $offset i32) - local.get $this - local.get $offset - i32.store offset=4 - ) - (func $assembly/codec/Decoder#get:offset (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/Decoder#get:source (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/codec/ValOffset#set:value (param $this i32) (param $value i32) - local.get $this - local.get $value - i32.store - ) - (func $assembly/codec/ValOffset#set:offset (param $this i32) (param $offset i32) - local.get $this - local.get $offset - i32.store offset=4 - ) - (func $assembly/codec/ValOffset#get:offset (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/ValOffset#get:value (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/CodeAndMetadata#set:code (param $this i32) (param $code i32) - local.get $this - local.get $code - i32.store - local.get $this - local.get $code - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/CodeAndMetadata#set:metadata (param $this i32) (param $metadata i32) - local.get $this - local.get $metadata - i32.store offset=4 - local.get $this - local.get $metadata - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/CodeAndMetadata#get:code (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/Mask#set:bytesToSkip (param $this i32) (param $bytesToSkip i32) - local.get $this - local.get $bytesToSkip - i32.store - local.get $this - local.get $bytesToSkip - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - ) - (func $assembly/program/JumpTable#set:jumps (param $this i32) (param $jumps i32) - local.get $this - local.get $jumps - i32.store - local.get $this - local.get $jumps - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - ) - (func $assembly/instructions/Instruction#get:isTerminating (param $this i32) (result i32) - local.get $this - i32.load8_u offset=16 - ) - (func $assembly/program/BasicBlocks#set:isStartOrEnd (param $this i32) (param $isStartOrEnd i32) - local.get $this - local.get $isStartOrEnd - i32.store - local.get $this - local.get $isStartOrEnd - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:code (param $this i32) (param $code i32) - local.get $this - local.get $code - i32.store - local.get $this - local.get $code - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:mask (param $this i32) (param $mask i32) - local.get $this - local.get $mask - i32.store offset=4 - local.get $this - local.get $mask - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:jumpTable (param $this i32) (param $jumpTable i32) - local.get $this - local.get $jumpTable - i32.store offset=8 - local.get $this - local.get $jumpTable - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:basicBlocks (param $this i32) (param $basicBlocks i32) - local.get $this - local.get $basicBlocks - i32.store offset=12 - local.get $this - local.get $basicBlocks - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/MemoryBuilder#set:pages (param $this i32) (param $pages i32) - local.get $this - local.get $pages - i32.store - local.get $this - local.get $pages - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/Arena#set:arenaBytes (param $this i32) (param $arenaBytes i32) - local.get $this - local.get $arenaBytes - i32.store offset=4 - ) - (func $assembly/memory-page/Arena#set:free (param $this i32) (param $free i32) - local.get $this - local.get $free - i32.store - local.get $this - local.get $free - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/MemoryBuilder#set:arena (param $this i32) (param $arena i32) - local.get $this - local.get $arena - i32.store offset=4 - local.get $this - local.get $arena - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/alignToSegmentSize (param $size i32) (result i32) - local.get $size - global.get $assembly/memory-page/SEGMENT_SIZE - i32.add - i32.const 1 - i32.sub - global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT - i32.shr_u - global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT - i32.shl - return - ) - (func $assembly/spi/alignToPageSize (param $size i32) (result i32) - local.get $size - global.get $assembly/memory-page/PAGE_SIZE - i32.add - i32.const 1 - i32.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - return - ) - (func $assembly/memory/MemoryBuilder#get:pages (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/MemoryBuilder#get:arena (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/Memory#set:arena (param $this i32) (param $arena i32) - local.get $this - local.get $arena - i32.store offset=4 - local.get $this - local.get $arena - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#set:pages (param $this i32) (param $pages i32) - local.get $this - local.get $pages - i32.store offset=8 - local.get $this - local.get $pages - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:program (param $this i32) (param $program i32) - local.get $this - local.get $program - i32.store offset=16 - local.get $this - local.get $program - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:memory (param $this i32) (param $memory i32) - local.get $this - local.get $memory - i32.store offset=20 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:registers (param $this i32) (param $registers i32) - local.get $this - local.get $registers - i32.store offset=24 - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:metadata (param $this i32) (param $metadata i32) - local.get $this - local.get $metadata - i32.store - local.get $this - local.get $metadata - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store offset=4 - ) - (func $assembly/spi/StandardProgram#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/interpreter/Interpreter#set:program (param $this i32) (param $program i32) - local.get $this - local.get $program - i32.store - local.get $this - local.get $program - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/interpreter/Interpreter#set:registers (param $this i32) (param $registers i32) - local.get $this - local.get $registers - i32.store offset=4 - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/interpreter/Interpreter#set:memory (param $this i32) (param $memory i32) - local.get $this - local.get $memory - i32.store offset=8 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/gas/GasCounterU64#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store - ) - (func $assembly/gas/gasCounter (param $gas i64) (result i32) - i32.const 0 - local.get $gas - call $assembly/gas/GasCounterU64#constructor - return - ) - (func $assembly/interpreter/Interpreter#set:gas (param $this i32) (param $gas i32) - local.get $this - local.get $gas - i32.store offset=12 - local.get $this - local.get $gas - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/interpreter/Interpreter#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store offset=16 - ) - (func $assembly/interpreter/Interpreter#set:status (param $this i32) (param $status i32) - local.get $this - local.get $status - i32.store offset=20 - ) - (func $assembly/interpreter/Interpreter#set:exitCode (param $this i32) (param $exitCode i32) - local.get $this - local.get $exitCode - i32.store offset=24 - ) - (func $assembly/interpreter/Interpreter#set:nextPc (param $this i32) (param $nextPc i32) - local.get $this - local.get $nextPc - i32.store offset=28 - ) - (func $assembly/interpreter/Interpreter#set:useSbrkGas (param $this i32) (param $useSbrkGas i32) - local.get $this - local.get $useSbrkGas - i32.store8 offset=32 - ) - (func $assembly/spi/StandardProgram#get:program (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $assembly/spi/StandardProgram#get:registers (param $this i32) (result i32) - local.get $this - i32.load offset=24 - ) - (func $assembly/spi/StandardProgram#get:memory (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $assembly/interpreter/Interpreter#get:gas (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/gas/GasCounter#set (param $this i32) (param $g i64) - unreachable - ) - (func $assembly/interpreter/Interpreter#get:memory (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/api-internal/InitialPage#set:address (param $this i32) (param $address i32) - local.get $this - local.get $address - i32.store - ) - (func $assembly/api-internal/InitialPage#set:length (param $this i32) (param $length i32) - local.get $this - local.get $length - i32.store offset=4 - ) - (func $assembly/api-internal/InitialPage#set:access (param $this i32) (param $access i32) - local.get $this - local.get $access - i32.store offset=8 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $assembly/api-internal/InitialChunk#set:address (param $this i32) (param $address i32) - local.get $this - local.get $address - i32.store - ) - (func $assembly/api-internal/InitialChunk#set:data (param $this i32) (param $data i32) - local.get $this - local.get $data - i32.store offset=4 - local.get $this - local.get $data - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-internal/InitialChunk#get:data (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $assembly/api-internal/InitialPage#get:access (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/api-internal/InitialPage#get:address (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/api-internal/InitialPage#get:length (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/api-internal/InitialChunk#get:address (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/interpreter/Interpreter#get:status (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $assembly/interpreter/Interpreter#get:nextPc (param $this i32) (result i32) - local.get $this - i32.load offset=28 - ) - (func $assembly/interpreter/Interpreter#get:pc (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $assembly/interpreter/Interpreter#get:program (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/instructions/Instruction#get:gas (param $this i32) (result i64) - local.get $this - i64.load offset=8 - ) - (func $assembly/gas/GasCounter#sub (param $this i32) (param $g i64) (result i32) - unreachable - ) - (func $assembly/interpreter/Interpreter#get:useSbrkGas (param $this i32) (result i32) - local.get $this - i32.load8_u offset=32 - ) - (func $assembly/interpreter/Interpreter#get:registers (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/outcome/OutcomeData#get:outcome (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/Program#get:jumpTable (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/instructions/outcome/OutcomeData#get:dJump (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/interpreter/DjumpResult#set:status (param $this i32) (param $status i32) - local.get $this - local.get $status - i32.store - ) - (func $assembly/interpreter/DjumpResult#set:newPc (param $this i32) (param $newPc i32) - local.get $this - local.get $newPc - i32.store offset=4 - ) - (func $assembly/program/JumpTable#get:jumps (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/interpreter/DjumpResult#get:status (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/Program#get:basicBlocks (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/interpreter/DjumpResult#get:newPc (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/interpreter/BranchResult#set:isOkay (param $this i32) (param $isOkay i32) - local.get $this - local.get $isOkay - i32.store8 - ) - (func $assembly/interpreter/BranchResult#set:newPc (param $this i32) (param $newPc i32) - local.get $this - local.get $newPc - i32.store offset=4 - ) - (func $assembly/program/BasicBlocks#get:isStartOrEnd (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/interpreter/BranchResult#get:isOkay (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $assembly/interpreter/BranchResult#get:newPc (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/outcome/OutcomeData#get:staticJump (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/outcome/OutcomeData#get:result (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/instructions/outcome/OutcomeData#get:exitCode (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $assembly/interpreter/Interpreter#get:exitCode (param $this i32) (result i32) - local.get $this - i32.load offset=24 - ) - (func $assembly/gas/GasCounter#get (param $this i32) (result i64) - unreachable - ) - (func $assembly/program/CodeAndMetadata#get:metadata (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $"~lib/map/Map#set:buckets" (param $this i32) (param $buckets i32) - local.get $this - local.get $buckets - i32.store - local.get $this - local.get $buckets - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $"~lib/map/Map#set:bucketsMask" (param $this i32) (param $bucketsMask i32) - local.get $this - local.get $bucketsMask - i32.store offset=4 - ) - (func $"~lib/map/Map#set:entries" (param $this i32) (param $entries i32) - local.get $this - local.get $entries - i32.store offset=8 - local.get $this - local.get $entries - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $"~lib/map/Map#set:entriesCapacity" (param $this i32) (param $entriesCapacity i32) - local.get $this - local.get $entriesCapacity - i32.store offset=12 - ) - (func $"~lib/map/Map#set:entriesOffset" (param $this i32) (param $entriesOffset i32) - local.get $this - local.get $entriesOffset - i32.store offset=16 - ) - (func $"~lib/map/Map#set:entriesCount" (param $this i32) (param $entriesCount i32) - local.get $this - local.get $entriesCount - i32.store offset=20 - ) - (func $assembly/gas-costs/BlockGasCost#get:pc (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $"~lib/map/Map#get:buckets" (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $"~lib/map/Map#get:bucketsMask" (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $"~lib/map/MapEntry#get:taggedNext" (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#get:key" (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $"~lib/map/MapEntry#set:value" (param $this i32) (param $value i32) - local.get $this - local.get $value - i32.store offset=4 - ) - (func $"~lib/map/Map#get:entriesOffset" (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $"~lib/map/Map#get:entriesCapacity" (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $"~lib/map/Map#get:entriesCount" (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $"~lib/map/Map#get:entries" (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#set:key" (param $this i32) (param $key i32) - local.get $this - local.get $key - i32.store - ) - (func $"~lib/map/MapEntry#get:value" (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $"~lib/map/MapEntry#set:taggedNext" (param $this i32) (param $taggedNext i32) - local.get $this - local.get $taggedNext - i32.store offset=8 - ) - (func $assembly/gas-costs/BlockGasCost#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store - ) - (func $assembly/gas-costs/BlockGasCost#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/gas-costs/BlockGasCost#get:gas (param $this i32) (result i64) - local.get $this - i64.load offset=8 - ) - (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/spi/StandardProgram#get:metadata (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/memory/memory.repeat (param $dst i32) (param $src i32) (param $srcLength i32) (param $count i32) - (local $index i32) - (local $total i32) - i32.const 0 - local.set $index - local.get $srcLength - local.get $count - i32.mul - local.set $total - loop $while-continue|0 - local.get $index - local.get $total - i32.lt_u - if - local.get $dst - local.get $index - i32.add - local.get $src - local.get $srcLength - memory.copy - local.get $index - local.get $srcLength - i32.add - local.set $index - br $while-continue|0 - end - end - ) - (func $assembly/api-internal/VmInput#set:program (param $this i32) (param $program i32) - local.get $this - local.get $program - i32.store offset=16 - local.get $this - local.get $program - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-internal/VmInput#set:memory (param $this i32) (param $memory i32) - local.get $this - local.get $memory - i32.store offset=20 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-internal/VmInput#set:registers (param $this i32) (param $registers i32) - local.get $this - local.get $registers - i32.store offset=24 - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-internal/VmInput#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store - ) - (func $assembly/api-internal/VmInput#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/api-internal/VmInput#get:program (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $assembly/api-internal/VmInput#get:registers (param $this i32) (result i32) - local.get $this - i32.load offset=24 - ) - (func $assembly/api-internal/VmInput#get:memory (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $assembly/api-internal/VmInput#get:pc (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/api-internal/VmInput#get:gas (param $this i32) (result i64) - local.get $this - i64.load offset=8 - ) - (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i64) (result i32) - (local $sign i32) - (local $dest i32) - (local $decimals i32) - (local $val32 i32) - (local $buffer|6 i32) - (local $num i32) - (local $offset i32) - (local $val64 i64) - (local $buffer|10 i32) - (local $num|11 i64) - (local $offset|12 i32) - i32.const 0 - local.set $sign - i32.const 0 - drop - local.get $buffer - local.get $sign - i32.const 1 - i32.shl - i32.add - local.set $dest - i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 0 - drop - local.get $value - i64.const 10 - i64.lt_u - if - local.get $buffer - local.get $value - i32.const 48 - i64.extend_i32_s - i64.or - i64.store16 - i32.const 1 - return - end - i32.const 0 - local.set $decimals - i32.const 8 - i32.const 4 - i32.le_u - drop - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - local.get $dest - local.set $buffer|6 - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|6 - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - local.set $val64 - local.get $val64 - call $~lib/util/number/decimalCount64High - local.set $decimals - local.get $dest - local.set $buffer|10 - local.get $val64 - local.set $num|11 - local.get $decimals - local.set $offset|12 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|10 - local.get $num|11 - local.get $offset|12 - call $~lib/util/number/utoa64_dec_lut - end - local.get $sign - local.get $decimals - i32.add - return - ) - (func $~lib/array/Array<~lib/string/String>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array<~lib/string/String>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/number/I64#toString (param $this i64) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/itoa64 - return - ) - (func $assembly/program/ResolvedArguments#set:a (param $this i32) (param $a i64) - local.get $this - local.get $a - i64.store - ) - (func $assembly/program/ResolvedArguments#set:b (param $this i32) (param $b i64) - local.get $this - local.get $b - i64.store offset=8 - ) - (func $assembly/program/ResolvedArguments#set:c (param $this i32) (param $c i64) - local.get $this - local.get $c - i64.store offset=16 - ) - (func $assembly/program/ResolvedArguments#set:d (param $this i32) (param $d i64) - local.get $this - local.get $d - i64.store offset=24 - ) - (func $assembly/program/ResolvedArguments#set:decoded (param $this i32) (param $decoded i32) - local.get $this - local.get $decoded - i32.store offset=32 - local.get $this - local.get $decoded - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/ResolvedArguments#get:a (param $this i32) (result i64) - local.get $this - i64.load - ) - (func $assembly/program/ResolvedArguments#get:decoded (param $this i32) (result i32) - local.get $this - i32.load offset=32 - ) - (func $assembly/program/ResolvedArguments#get:b (param $this i32) (result i64) - local.get $this - i64.load offset=8 - ) - (func $assembly/program/ResolvedArguments#get:c (param $this i32) (result i64) - local.get $this - i64.load offset=16 - ) - (func $assembly/program/ResolvedArguments#get:d (param $this i32) (result i64) - local.get $this - i64.load offset=24 - ) - (func $assembly/api-internal/VmOutput#set:status (param $this i32) (param $status i32) - local.get $this - local.get $status - i32.store - ) - (func $assembly/api-internal/VmOutput#set:registers (param $this i32) (param $registers i32) - local.get $this - local.get $registers - i32.store offset=4 - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-internal/VmOutput#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store offset=8 - ) - (func $assembly/api-internal/VmOutput#set:memory (param $this i32) (param $memory i32) - local.get $this - local.get $memory - i32.store offset=12 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/api-internal/VmOutput#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=16 - ) - (func $assembly/api-internal/VmOutput#set:exitCode (param $this i32) (param $exitCode i32) - local.get $this - local.get $exitCode - i32.store offset=24 - ) - (func $~lib/array/Array#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/array/Array#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/array/Array#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $~lib/rt/itcms/__pin (param $ptr i32) (result i32) - (local $obj i32) - local.get $ptr - if - local.get $ptr - i32.const 20 - i32.sub - local.set $obj - local.get $obj - call $~lib/rt/itcms/Object#get:color - i32.const 3 - i32.eq - if - i32.const 20416 - i32.const 352 - i32.const 338 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $obj - call $~lib/rt/itcms/Object#unlink - local.get $obj - global.get $~lib/rt/itcms/pinSpace - i32.const 3 - call $~lib/rt/itcms/Object#linkTo - end - local.get $ptr - return - ) - (func $~lib/rt/itcms/__unpin (param $ptr i32) - (local $obj i32) - local.get $ptr - i32.eqz - if - return - end - local.get $ptr - i32.const 20 - i32.sub - local.set $obj - local.get $obj - call $~lib/rt/itcms/Object#get:color - i32.const 3 - i32.ne - if - i32.const 20480 - i32.const 352 - i32.const 352 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/state - i32.const 1 - i32.eq - if - local.get $obj - call $~lib/rt/itcms/Object#makeGray - else - local.get $obj - call $~lib/rt/itcms/Object#unlink - local.get $obj - global.get $~lib/rt/itcms/fromSpace - global.get $~lib/rt/itcms/white - call $~lib/rt/itcms/Object#linkTo - end - ) - (func $~lib/rt/itcms/__collect - i32.const 0 - drop - global.get $~lib/rt/itcms/state - i32.const 0 - i32.gt_s - if - loop $while-continue|0 - global.get $~lib/rt/itcms/state - i32.const 0 - i32.ne - if - call $~lib/rt/itcms/step - drop - br $while-continue|0 - end - end - end - call $~lib/rt/itcms/step - drop - loop $while-continue|1 - global.get $~lib/rt/itcms/state - i32.const 0 - i32.ne - if - call $~lib/rt/itcms/step - drop - br $while-continue|1 - end - end - global.get $~lib/rt/itcms/total - i64.extend_i32_u - i32.const 200 - i64.extend_i32_u - i64.mul - i64.const 100 - i64.div_u - i32.wrap_i64 - i32.const 1024 - i32.add - global.set $~lib/rt/itcms/threshold - i32.const 0 - drop - i32.const 0 - drop - ) - (func $assembly/gas/GasCounterU64#get:gas (param $this i32) (result i64) - local.get $this - i64.load - ) - (func $assembly/gas/GasCounter#set@override (param $0 i32) (param $1 i64) - (local $2 i32) - block $default - block $case0 - local.get $0 - i32.const 8 - i32.sub - i32.load - local.set $2 - local.get $2 - i32.const 46 - i32.eq - br_if $case0 - br $default - end - local.get $0 - local.get $1 - call $assembly/gas/GasCounterU64#set - return - end - unreachable - ) - (func $assembly/gas/GasCounter#sub@override (param $0 i32) (param $1 i64) (result i32) - (local $2 i32) - block $default - block $case0 - local.get $0 - i32.const 8 - i32.sub - i32.load - local.set $2 - local.get $2 - i32.const 46 - i32.eq - br_if $case0 - br $default - end - local.get $0 - local.get $1 - call $assembly/gas/GasCounterU64#sub - return - end - unreachable - ) - (func $assembly/gas/GasCounter#get@override (param $0 i32) (result i64) - (local $1 i32) - block $default - block $case0 - local.get $0 - i32.const 8 - i32.sub - i32.load - local.set $1 - local.get $1 - i32.const 46 - i32.eq - br_if $case0 - br $default - end - local.get $0 - call $assembly/gas/GasCounterU64#get - return - end - unreachable - ) - (func $~lib/rt/__visit_globals (param $0 i32) - (local $1 i32) - i32.const 480 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 8176 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 11424 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 14704 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 9376 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 288 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 20416 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 20480 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 15488 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 16544 - local.get $0 - call $~lib/rt/itcms/__visit - global.get $assembly/api-debugger/interpreter - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/codec/MASKS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_PAGE - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/RELEVANT_ARGS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/REQUIRED_BYTES - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/DECODERS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/INSTRUCTIONS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions-exe/RUN - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - ) - (func $~lib/arraybuffer/ArrayBufferView~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/object/Object~visit (param $0 i32) (param $1 i32) - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/typedarray/Uint8Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/memory-page/Page~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory-page/RawPage~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/Memory~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory-page/Arena~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $"~lib/map/Map~visit" (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $"~lib/map/Map#__visit" - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit - ) - (func $assembly/memory/Result~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/ChunkBytes~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/Chunks~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/PageData~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/function/Function<%28u8%29=>u8>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28u8%29=>u8>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28u8%29=>u8>#__visit - ) - (func $assembly/interpreter/Interpreter~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/Program~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/Mask~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/JumpTable~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/BasicBlocks~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - i32.const 1 - drop - local.get $this - local.set $cur - local.get $cur - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray<~lib/string/String>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/dataview/DataView~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/CodeAndMetadata~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/codec/Decoder~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/spi/StandardProgram~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=16 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=20 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=24 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/MemoryBuilder~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/api-internal/InitialChunk~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $"~lib/map/Map~visit" (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $"~lib/map/Map#__visit" - ) - (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit - ) - (func $assembly/api-internal/VmOutput~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/api-internal/VmInput~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=16 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=20 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=24 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array<~lib/string/String>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<~lib/string/String>#__visit - ) - (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit - ) - (func $assembly/program/ResolvedArguments~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=32 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/rt/__visit_members (param $0 i32) (param $1 i32) - block $invalid - block $assembly/program/ResolvedArguments - block $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> - block $~lib/array/Array<~lib/string/String> - block $assembly/api-internal/VmInput - block $assembly/api-internal/VmOutput - block $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> - block $"~lib/map/Map" - block $~lib/array/Array - block $~lib/array/Array - block $assembly/gas-costs/BlockGasCost - block $assembly/interpreter/BranchResult - block $assembly/interpreter/DjumpResult - block $~lib/array/Array - block $assembly/api-internal/InitialChunk - block $~lib/array/Array - block $assembly/api-internal/InitialPage - block $~lib/array/Array - block $assembly/gas/GasCounterU64 - block $assembly/memory/MemoryBuilder - block $assembly/spi/StandardProgram - block $assembly/codec/ValOffset - block $assembly/codec/Decoder - block $assembly/program/CodeAndMetadata - block $~lib/dataview/DataView - block $~lib/staticarray/StaticArray - block $~lib/array/Array - block $~lib/staticarray/StaticArray<~lib/string/String> - block $assembly/gas/GasCounter - block $~lib/staticarray/StaticArray - block $assembly/program/BasicBlocks - block $assembly/program/JumpTable - block $~lib/staticarray/StaticArray - block $assembly/program/Mask - block $assembly/program/Program - block $assembly/interpreter/Interpreter - block $~lib/function/Function<%28u8%29=>u8> - block $~lib/array/Array - block $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> - block $assembly/memory/PageData - block $assembly/memory/Chunks - block $~lib/staticarray/StaticArray - block $assembly/memory/ChunkBytes - block $assembly/memory/Result - block $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> - block $assembly/instructions/outcome/OutcomeData - block $"~lib/map/Map" - block $~lib/array/Array - block $assembly/memory-page/Arena - block $assembly/memory/Memory - block $~lib/staticarray/StaticArray - block $assembly/memory-page/RawPage - block $assembly/memory-page/Page - block $assembly/memory/MaybePageFault - block $~lib/array/Array - block $assembly/arguments/Nibbles - block $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> - block $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> - block $assembly/arguments/Args - block $~lib/typedarray/Uint8Array - block $~lib/array/Array - block $~lib/arraybuffer/ArrayBufferView - block $~lib/string/String - block $~lib/arraybuffer/ArrayBuffer - block $~lib/object/Object - local.get $0 - i32.const 8 - i32.sub - i32.load - br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $~lib/arraybuffer/ArrayBufferView $~lib/array/Array $~lib/typedarray/Uint8Array $assembly/arguments/Args $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $assembly/arguments/Nibbles $~lib/array/Array $assembly/memory/MaybePageFault $assembly/memory-page/Page $assembly/memory-page/RawPage $~lib/staticarray/StaticArray $assembly/memory/Memory $assembly/memory-page/Arena $~lib/array/Array $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $assembly/memory/Result $assembly/memory/ChunkBytes $~lib/staticarray/StaticArray $assembly/memory/Chunks $assembly/memory/PageData $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $~lib/array/Array $~lib/function/Function<%28u8%29=>u8> $assembly/interpreter/Interpreter $assembly/program/Program $assembly/program/Mask $~lib/staticarray/StaticArray $assembly/program/JumpTable $assembly/program/BasicBlocks $~lib/staticarray/StaticArray $assembly/gas/GasCounter $~lib/staticarray/StaticArray<~lib/string/String> $~lib/array/Array $~lib/staticarray/StaticArray $~lib/dataview/DataView $assembly/program/CodeAndMetadata $assembly/codec/Decoder $assembly/codec/ValOffset $assembly/spi/StandardProgram $assembly/memory/MemoryBuilder $assembly/gas/GasCounterU64 $~lib/array/Array $assembly/api-internal/InitialPage $~lib/array/Array $assembly/api-internal/InitialChunk $~lib/array/Array $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $assembly/gas-costs/BlockGasCost $~lib/array/Array $~lib/array/Array $"~lib/map/Map" $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String> $assembly/api-internal/VmOutput $assembly/api-internal/VmInput $~lib/array/Array<~lib/string/String> $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String> $assembly/program/ResolvedArguments $invalid - end - return - end - return - end - return - end - local.get $0 - local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/typedarray/Uint8Array~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/Page~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/RawPage~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory/Memory~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/Arena~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $"~lib/map/Map~visit" - return - end - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/Result~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/ChunkBytes~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory/Chunks~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/PageData~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28u8%29=>u8>~visit - return - end - local.get $0 - local.get $1 - call $assembly/interpreter/Interpreter~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/Program~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/Mask~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/program/JumpTable~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/BasicBlocks~visit - return - end - return - end - return - end - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray<~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/dataview/DataView~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/CodeAndMetadata~visit - return - end - local.get $0 - local.get $1 - call $assembly/codec/Decoder~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/spi/StandardProgram~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/MemoryBuilder~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $assembly/api-internal/InitialChunk~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - return - end - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $"~lib/map/Map~visit" - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $assembly/api-internal/VmOutput~visit - return - end - local.get $0 - local.get $1 - call $assembly/api-internal/VmInput~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/ResolvedArguments~visit - return - end - unreachable - ) - (func $~setArgumentsLength (param $0 i32) - local.get $0 - global.set $~argumentsLength - ) - (func $~start - call $start:assembly/index - ) - (func $~stack_check - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__data_end - i32.lt_s - if - i32.const 53584 - i32.const 53632 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - ) - (func $assembly/arguments/Args#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 6 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:b - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:c - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:d - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/arguments/Args.from (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32) - (local $x i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $x - i32.store - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $a - call $assembly/arguments/Args#set:a - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $b - call $assembly/arguments/Args#set:b - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $c - call $assembly/arguments/Args#set:c - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $d - call $assembly/arguments/Args#set:d - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/typedarray/Uint8Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/typedarray/Uint8Array#subarray (param $this i32) (param $begin i32) (param $end i32) (result i32) - (local $array i32) - (local $begin|4 i32) - (local $end|5 i32) - (local $len i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $14 i32) - (local $15 i32) - (local $16 i32) - (local $out i32) - (local $buf i32) - (local $19 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - block $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $array - i32.store - local.get $begin - local.set $begin|4 - local.get $end - local.set $end|5 - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - local.get $begin|4 - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $begin|4 - i32.add - local.tee $7 - i32.const 0 - local.tee $8 - local.get $7 - local.get $8 - i32.gt_s - select - else - local.get $begin|4 - local.tee $9 - local.get $len - local.tee $10 - local.get $9 - local.get $10 - i32.lt_s - select - end - local.set $begin|4 - local.get $end|5 - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $end|5 - i32.add - local.tee $11 - i32.const 0 - local.tee $12 - local.get $11 - local.get $12 - i32.gt_s - select - else - local.get $end|5 - local.tee $13 - local.get $len - local.tee $14 - local.get $13 - local.get $14 - i32.lt_s - select - end - local.set $end|5 - local.get $end|5 - local.tee $15 - local.get $begin|4 - local.tee $16 - local.get $15 - local.get $16 - i32.gt_s - select - local.set $end|5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=8 - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $buf - local.get $out - local.get $buf - i32.store - local.get $out - local.get $buf - i32.const 0 - call $~lib/rt/itcms/__link - local.get $out - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $begin|4 - i32.const 0 - i32.shl - i32.add - i32.store offset=4 - local.get $out - local.get $end|5 - local.get $begin|4 - i32.sub - i32.const 0 - i32.shl - i32.store offset=8 - local.get $out - br $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" - end - local.set $19 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $19 - return - ) - (func $~lib/typedarray/Uint8Array#__get (param $this i32) (param $index i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - i32.ge_u - if - i32.const 480 - i32.const 720 - i32.const 167 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $index - i32.add - i32.load8_u - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/arguments/decodeI32 (param $input i32) (param $start i32) (param $end i32) (result i32) - (local $data i32) - (local $value1 f64) - (local $value2 f64) - (local $len i32) - (local $num i32) - (local $i i32) - (local $msb i32) - (local $prefix i32) - (local $i|11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $input - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $start - local.get $end - local.get $start - i32.gt_u - if (result i32) - local.get $end - else - local.get $start - end - call $~lib/typedarray/Uint8Array#subarray - local.tee $data - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.0 (result f64) - f64.const 4 - local.set $value1 - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.0 - end - i32.trunc_sat_f64_u - local.set $len - i32.const 0 - local.set $num - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_u - if - local.get $num - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.get $i - i32.const 8 - i32.mul - i32.shl - i32.or - local.set $num - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $len - i32.const 0 - i32.gt_u - if (result i32) - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $len - i32.const 1 - i32.sub - call $~lib/typedarray/Uint8Array#__get - i32.const 128 - i32.and - else - i32.const 0 - end - local.set $msb - local.get $msb - i32.const 0 - i32.gt_u - if (result i32) - i32.const 255 - else - i32.const 0 - end - local.set $prefix - local.get $len - local.set $i|11 - loop $for-loop|1 - local.get $i|11 - i32.const 4 - i32.lt_u - if - local.get $num - local.get $prefix - local.get $i|11 - i32.const 8 - i32.mul - i32.shl - i32.or - local.set $num - local.get $i|11 - i32.const 1 - i32.add - local.set $i|11 - br $for-loop|1 - end - end - local.get $num - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $start:assembly/arguments~anonymous|1 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/arguments/Nibbles#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 2 - i32.const 9 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Nibbles#set:low - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Nibbles#set:hig - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/arguments/nibbles (param $byte i32) (result i32) - (local $low i32) - (local $hig i32) - (local $n i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $byte - i32.const 15 - i32.and - local.set $low - local.get $byte - i32.const 255 - i32.and - i32.const 4 - i32.const 7 - i32.and - i32.shr_u - local.set $hig - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Nibbles#constructor - local.tee $n - i32.store - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $low - call $assembly/arguments/Nibbles#set:low - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $hig - call $assembly/arguments/Nibbles#set:hig - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/arguments/twoImm (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $first i32) - (local $second i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.1 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.1 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $first - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $second - local.get $first - local.get $second - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|2 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $lim - call $assembly/arguments/twoImm - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $start:assembly/arguments~anonymous|3 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/arguments~anonymous|4 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/typedarray/Uint8Array#subarray@varargs (param $this i32) (param $begin i32) (param $end i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $begin - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $begin - local.get $end - call $~lib/typedarray/Uint8Array#subarray - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/arguments/decodeU32 (param $data i32) (result i32) - (local $num i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 2 - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 3 - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - local.set $num - local.get $num - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/arguments~anonymous|5 (param $data i32) (param $_lim i32) (result i32) - (local $a i32) - (local $b i32) - (local $c i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Nibbles#get:low - local.set $a - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/decodeU32 - local.set $b - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 5 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/decodeU32 - local.set $c - local.get $a - i32.const 255 - i32.and - local.get $b - local.get $c - i32.const 0 - call $assembly/arguments/Args.from - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/arguments~anonymous|6 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $immA i32) - (local $immB i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.2 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.2 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $immA - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $immB - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $immA - local.get $immB - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|7 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $immA i32) - (local $offs i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.3 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.3 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $immA - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $offs - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $immA - local.get $offs - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|8 (param $data i32) (param $_lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|9 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|10 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|11 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - i32.const 1 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $lim - i32.const 1 - i32.gt_u - if (result i32) - local.get $lim - i32.const 1 - i32.sub - else - i32.const 0 - end - call $assembly/arguments/twoImm - local.tee $result - i32.store offset=12 - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:a - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/arguments/Args.from - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/arguments~anonymous|12 (param $data i32) (param $_lim i32) (result i32) - (local $a i32) - (local $b i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $a - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $b - i32.store offset=8 - local.get $a - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $a - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $b - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - i32.const 0 - call $assembly/arguments/Args.from - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/array/ensureCapacity (param $array i32) (param $newSize i32) (param $alignLog2 i32) (param $canGrow i32) - (local $oldCapacity i32) - (local $oldData i32) - (local $6 i32) - (local $7 i32) - (local $newCapacity i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $newData i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $array - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - local.set $oldCapacity - local.get $newSize - local.get $oldCapacity - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - local.get $newSize - i32.const 1073741820 - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8128 - i32.const 19 - i32.const 48 - call $~lib/builtins/abort - unreachable - end - local.get $array - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $oldData - local.get $newSize - local.tee $6 - i32.const 8 - local.tee $7 - local.get $6 - local.get $7 - i32.gt_u - select - local.get $alignLog2 - i32.shl - local.set $newCapacity - local.get $canGrow - if - local.get $oldCapacity - i32.const 1 - i32.shl - local.tee $9 - i32.const 1073741820 - local.tee $10 - local.get $9 - local.get $10 - i32.lt_u - select - local.tee $11 - local.get $newCapacity - local.tee $12 - local.get $11 - local.get $12 - i32.gt_u - select - local.set $newCapacity - end - local.get $oldData - local.get $newCapacity - call $~lib/rt/itcms/__renew - local.set $newData - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $newData - local.get $oldData - i32.ne - if - local.get $array - local.get $newData - i32.store - local.get $array - local.get $newData - i32.store offset=4 - local.get $array - local.get $newData - i32.const 0 - call $~lib/rt/itcms/__link - end - local.get $array - local.get $newCapacity - i32.store offset=8 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 1296 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/MISSING_INSTRUCTION - i32.const 1344 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/SBRK - global.get $~lib/memory/__stack_pointer - i32.const 231 - i32.const 2 - i32.const 10 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.const 1376 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 1408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 5 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 6 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 7 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 8 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 9 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 10 - i32.const 1456 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 11 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 12 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 13 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 14 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 15 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 16 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 17 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 18 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 19 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 20 - i32.const 1488 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneExtImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 21 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 22 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 23 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 24 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 25 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 26 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 27 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 28 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 29 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 30 - i32.const 1536 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 31 - i32.const 1584 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 32 - i32.const 1632 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 33 - i32.const 1680 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 34 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 35 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 36 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 37 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 38 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 39 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 40 - i32.const 1728 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 41 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 42 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 43 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 44 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 45 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 46 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 47 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 48 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 49 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 50 - i32.const 1760 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 51 - i32.const 1808 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 52 - i32.const 1856 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 53 - i32.const 1904 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 54 - i32.const 1952 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 55 - i32.const 2000 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 56 - i32.const 2048 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 57 - i32.const 2096 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 58 - i32.const 2144 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 59 - i32.const 2192 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 60 - i32.const 2240 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 61 - i32.const 2288 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 62 - i32.const 2336 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 63 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 64 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 65 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 66 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 67 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 68 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 69 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 70 - i32.const 2384 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 71 - i32.const 2448 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 72 - i32.const 2512 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 73 - i32.const 2576 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 74 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 75 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 76 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 77 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 78 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 79 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 80 - i32.const 2640 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 81 - i32.const 2688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 82 - i32.const 2736 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 83 - i32.const 2784 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 84 - i32.const 2848 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 85 - i32.const 2912 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 86 - i32.const 2976 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 87 - i32.const 3040 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 88 - i32.const 3104 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 89 - i32.const 3168 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 90 - i32.const 3232 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 91 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 92 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 93 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 94 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 95 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 96 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 97 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 98 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 99 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 100 - i32.const 3296 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 101 - global.get $assembly/instructions/SBRK - call $~lib/array/Array#__set - local.get $0 - i32.const 102 - i32.const 3344 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 103 - i32.const 3408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 104 - i32.const 3472 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 105 - i32.const 3536 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 106 - i32.const 3600 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 107 - i32.const 3664 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 108 - i32.const 3728 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 109 - i32.const 3776 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 110 - i32.const 3824 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 111 - i32.const 3872 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 112 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 113 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 114 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 115 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 116 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 117 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 118 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 119 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 120 - i32.const 3920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 121 - i32.const 3968 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 122 - i32.const 4016 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 123 - i32.const 4064 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 124 - i32.const 4112 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 125 - i32.const 4160 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 126 - i32.const 4208 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 127 - i32.const 4256 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 128 - i32.const 4304 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 129 - i32.const 4352 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 130 - i32.const 4400 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 131 - i32.const 4448 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 132 - i32.const 4496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 133 - i32.const 4544 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 134 - i32.const 4592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 135 - i32.const 4624 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 136 - i32.const 4672 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 137 - i32.const 4720 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 138 - i32.const 4768 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 139 - i32.const 4816 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 140 - i32.const 4864 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 141 - i32.const 4912 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 142 - i32.const 4960 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 143 - i32.const 5008 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 144 - i32.const 5056 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 145 - i32.const 5120 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 146 - i32.const 5184 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 147 - i32.const 5248 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 148 - i32.const 5296 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 149 - i32.const 5344 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 150 - i32.const 5392 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 151 - i32.const 5440 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 152 - i32.const 5488 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 153 - i32.const 5536 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 154 - i32.const 5584 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 155 - i32.const 5632 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 156 - i32.const 5696 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 157 - i32.const 5760 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 158 - i32.const 5824 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 159 - i32.const 5872 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 160 - i32.const 5936 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 161 - i32.const 5984 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 162 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 163 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 164 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 165 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 166 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 167 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 168 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 169 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 170 - i32.const 6048 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 171 - i32.const 6096 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 172 - i32.const 6144 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 173 - i32.const 6192 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 174 - i32.const 6240 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 175 - i32.const 6288 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 176 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 177 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 178 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 179 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 180 - i32.const 6336 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegTwoImm - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 181 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 182 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 183 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 184 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 185 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 186 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 187 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 188 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 189 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 190 - i32.const 6400 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 191 - i32.const 6432 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 192 - i32.const 6464 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 193 - i32.const 6496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 194 - i32.const 6544 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 195 - i32.const 6592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 196 - i32.const 6640 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 197 - i32.const 6688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 198 - i32.const 6736 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 199 - i32.const 6784 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 200 - i32.const 6832 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 201 - i32.const 6864 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 202 - i32.const 6896 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 203 - i32.const 6928 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 204 - i32.const 6976 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 205 - i32.const 7024 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 206 - i32.const 7072 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 207 - i32.const 7120 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 208 - i32.const 7168 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 209 - i32.const 7216 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 210 - i32.const 7264 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 211 - i32.const 7296 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 212 - i32.const 7328 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 213 - i32.const 7360 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 214 - i32.const 7408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 215 - i32.const 7456 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 216 - i32.const 7504 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 217 - i32.const 7552 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 218 - i32.const 7600 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 219 - i32.const 7648 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 220 - i32.const 7696 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 221 - i32.const 7744 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 222 - i32.const 7792 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 223 - i32.const 7840 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 224 - i32.const 7888 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 225 - i32.const 7936 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 226 - i32.const 7968 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 227 - i32.const 8000 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 228 - i32.const 8032 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 229 - i32.const 8064 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 230 - i32.const 8096 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/INSTRUCTIONS - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MaybePageFault#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 11 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:isFault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:isAccess - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:fault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/arraybuffer/ArrayBufferView#constructor (param $this i32) (param $length i32) (param $alignLog2 i32) (result i32) - (local $buffer i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 3 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:buffer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:byteLength - local.get $length - i32.const 1073741820 - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8224 - i32.const 19 - i32.const 57 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $length - local.get $alignLog2 - i32.shl - local.tee $length - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $buffer - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $~lib/arraybuffer/ArrayBufferView#set:buffer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $buffer - call $~lib/arraybuffer/ArrayBufferView#set:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $length - call $~lib/arraybuffer/ArrayBufferView#set:byteLength - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $length - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#constructor - local.tee $this - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/memory-page/Page#constructor (param $this i32) (param $access i32) (param $raw i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 12 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $access - call $assembly/memory-page/Page#set:access - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $raw - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory-page/Page#set:raw - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory-page/RawPage#constructor (param $this i32) (param $id i32) (param $page i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 13 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $id - call $assembly/memory-page/RawPage#set:id - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $page - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory-page/RawPage#set:page - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $start:assembly/memory - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - call $start:assembly/memory-page - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - global.set $assembly/memory/NO_PAGE_FAULT - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - global.set $assembly/memory/EMPTY_UINT8ARRAY - i32.const 0 - global.get $assembly/memory-page/Access.None - i32.const 0 - i32.const -1 - i32.const 0 - call $assembly/memory-page/RawPage#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/memory-page/Page#constructor - global.set $assembly/memory/EMPTY_PAGE - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i64) - (local $value i64) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/OutcomeData#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.const 19 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/instructions/outcome/Outcome.Ok - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:staticJump - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:dJump - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/instructions/outcome/Result.PANIC - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:exitCode - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/bit~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.popcnt - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.popcnt - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.clz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.clz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ctz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.ctz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u8SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u16SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|8 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.const 65535 - i32.and - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|9 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/polyfills/bswap - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/instructions/outcome/staticJump (param $offset i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.StaticJump - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $offset - call $assembly/instructions/outcome/OutcomeData#set:staticJump - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/branch~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.eq - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.ne - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.lt_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.le_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.ge_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.gt_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.lt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.le_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.ge_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.gt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.eq - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ne - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_u - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ge_u - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ge_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/jump~anonymous|0 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:a - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/instructions/outcome/dJump (param $address i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.DynamicJump - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $address - call $assembly/instructions/outcome/OutcomeData#set:dJump - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/jump~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $address i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - local.get $address - call $assembly/instructions/outcome/dJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/jump~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/jump~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $address i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:d - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - local.get $address - call $assembly/instructions/outcome/dJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.const 32 - i64.shl - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/load~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory/Chunks#constructor (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 24 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:fault - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:first - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:second - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory/Chunks#constructor@varargs (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $first - i32.store - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $second - i32.store offset=4 - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - local.get $first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - local.get $second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - local.get $4 - call $assembly/memory/Chunks#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $"~lib/map/Map#find" (param $this i32) (param $key i32) (param $hashCode i32) (result i32) - (local $entry i32) - (local $taggedNext i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - i32.load - local.set $entry - loop $while-continue|0 - local.get $entry - if - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - local.set $taggedNext - local.get $taggedNext - i32.const 1 - i32.and - i32.eqz - if (result i32) - local.get $entry - call $"~lib/map/MapEntry#get:key" - local.get $key - i32.eq - else - i32.const 0 - end - if - local.get $entry - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $taggedNext - i32.const 1 - i32.const -1 - i32.xor - i32.and - local.set $entry - br $while-continue|0 - end - end - i32.const 0 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $"~lib/map/Map#has" (param $this i32) (param $key i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $key - local.get $key - call $~lib/util/hash/HASH - call $"~lib/map/Map#find" - i32.const 0 - i32.ne - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/PageData#constructor (param $this i32) (param $fault i32) (param $page i32) (param $relativeAddress i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 25 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/PageData#set:fault - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $page - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/PageData#set:page - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $relativeAddress - call $assembly/memory/PageData#set:relativeAddress - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory/fault (param $address i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isFault - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $address - call $assembly/memory/MaybePageFault#set:fault - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $"~lib/map/Map#get" (param $this i32) (param $key i32) (result i32) - (local $entry i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $key - local.get $key - call $~lib/util/hash/HASH - call $"~lib/map/Map#find" - local.set $entry - local.get $entry - i32.eqz - if - i32.const 9376 - i32.const 9440 - i32.const 105 - i32.const 17 - call $~lib/builtins/abort - unreachable - end - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory-page/Page#can (param $this i32) (param $access i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/Page#get:access - global.get $assembly/memory-page/Access.Write - i32.eq - if (result i32) - i32.const 1 - else - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/Page#get:access - local.get $access - i32.eq - end - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/Memory#getPage (param $this i32) (param $access i32) (param $address i32) (result i32) - (local $pageIdx i32) - (local $relAddress i32) - (local $pageStart i32) - (local $page i32) - (local $f i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $address - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $pageIdx - local.get $address - global.get $assembly/memory-page/PAGE_SIZE - i32.rem_u - local.set $relAddress - local.get $pageIdx - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - local.set $pageStart - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/memory/Memory#get:pages - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $pageIdx - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.get $pageStart - call $assembly/memory/fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory/EMPTY_PAGE - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/memory/Memory#get:pages - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $pageIdx - call $"~lib/map/Map#get" - local.tee $page - i32.store offset=8 - local.get $page - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $access - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $pageStart - call $assembly/memory/fault - local.tee $f - i32.store offset=12 - local.get $f - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isAccess - i32.const 0 - local.get $f - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory/EMPTY_PAGE - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $page - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/typedarray/Uint8Array#fill (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $value - local.get $start - local.get $end - call $~lib/util/bytes/FILL - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/typedarray/Uint8Array#fill@varargs (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $value - local.get $start - local.get $end - call $~lib/typedarray/Uint8Array#fill - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory-page/RawPage#get:data (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:page - i32.const 0 - i32.eq - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory-page/RawPage#set:page - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:page - local.tee $1 - i32.store offset=12 - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 9616 - i32.const 46 - i32.const 12 - call $~lib/builtins/abort - unreachable - end - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/Memory#getChunks (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) - (local $pageData i32) - (local $page i32) - (local $relativeAddress i32) - (local $endAddress i32) - (local $needSecondPage i32) - (local $first i32) - (local $secondPageIdx i32) - (local $secondPageStart i32) - (local $secondPage i32) - (local $f i32) - (local $firstChunk i32) - (local $secondChunk i32) - (local $16 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $bytes - i32.const 255 - i32.and - i32.const 0 - i32.eq - if - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $access - local.get $address - call $assembly/memory/Memory#getPage - local.tee $pageData - i32.store offset=4 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/PageData#get:fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/MaybePageFault#get:isFault - if - i32.const 0 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/PageData#get:fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/PageData#get:page - local.tee $page - i32.store offset=12 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/PageData#get:relativeAddress - local.set $relativeAddress - local.get $relativeAddress - local.get $bytes - i32.const 255 - i32.and - i32.add - local.set $endAddress - local.get $endAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.gt_u - local.set $needSecondPage - local.get $needSecondPage - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $page - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $relativeAddress - local.get $endAddress - call $~lib/typedarray/Uint8Array#subarray - local.tee $first - i32.store offset=20 - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $first - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - i32.const 2 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - local.get $address - local.get $bytes - i32.const 255 - i32.and - i32.add - i64.extend_i32_u - global.get $assembly/memory/MEMORY_SIZE - i64.rem_s - i32.wrap_i64 - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $secondPageIdx - local.get $secondPageIdx - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - local.set $secondPageStart - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/Memory#get:pages - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $secondPageIdx - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.get $secondPageStart - call $assembly/memory/fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/Memory#get:pages - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $secondPageIdx - call $"~lib/map/Map#get" - local.tee $secondPage - i32.store offset=24 - local.get $secondPage - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $access - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $secondPageStart - call $assembly/memory/fault - local.tee $f - i32.store offset=28 - local.get $f - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isAccess - i32.const 0 - local.get $f - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $page - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $relativeAddress - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $firstChunk - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $secondPage - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - local.get $relativeAddress - local.get $bytes - i32.const 255 - i32.and - i32.add - global.get $assembly/memory-page/PAGE_SIZE - i32.sub - call $~lib/typedarray/Uint8Array#subarray - local.tee $secondChunk - i32.store offset=36 - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $firstChunk - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - local.get $secondChunk - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory/Chunks#constructor - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - ) - (func $assembly/memory/ChunkBytes#constructor (param $this i32) (param $fault i32) (param $bytes i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 22 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $fault - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory/ChunkBytes#set:fault - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $bytes - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory/ChunkBytes#set:bytes - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/ChunkBytes#constructor@varargs (param $this i32) (param $fault i32) (param $bytes i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/staticarray/StaticArray#constructor - local.tee $bytes - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $fault - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $bytes - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/memory/ChunkBytes#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/getBytes (param $bytes i32) (param $first i32) (param $second i32) (result i32) - (local $res i32) - (local $len i32) - (local $i i32) - (local $i|6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $bytes - i32.const 255 - i32.and - call $~lib/staticarray/StaticArray#constructor - local.tee $res - i32.store - local.get $first - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $i - local.get $first - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|6 - loop $for-loop|1 - local.get $i|6 - local.get $second - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $len - local.get $i|6 - i32.add - local.get $second - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - local.get $i|6 - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $i|6 - i32.const 1 - i32.add - local.set $i|6 - br $for-loop|1 - end - end - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $assembly/memory/Memory#getBytes (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) - (local $res i32) - (local $data i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $access - local.get $address - local.get $bytes - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $assembly/memory/MaybePageFault#get:isFault - if - i32.const 0 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/ChunkBytes#constructor@varargs - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - global.get $~lib/memory/__stack_pointer - local.get $bytes - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:first - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:second - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/getBytes - local.tee $data - i32.store offset=16 - i32.const 0 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/ChunkBytes#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/memory/Result#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 21 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/memory/Result#set:ok - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/Result#set:fault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory/Memory#getU8 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/instructions/outcome/okOrFault (param $pageFault i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MaybePageFault#get:isAccess - if (result i32) - global.get $assembly/instructions/outcome/Result.FAULT_ACCESS - else - global.get $assembly/instructions/outcome/Result.FAULT - end - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MaybePageFault#get:fault - call $assembly/instructions/outcome/OutcomeData#set:exitCode - end - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/load~anonymous|2 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getI8 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/u8SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|3 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU16 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getI16 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $l i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/Result#set:fault - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.const 15 - i32.and - i32.shl - i32.or - local.set $l - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $l - call $assembly/instructions/utils/u16SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU32 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getI32 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $l i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/Result#set:fault - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i32.or - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i32.or - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i32.or - local.set $l - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $l - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU64 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 8 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 8 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 16 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 24 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 4 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 32 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 5 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 40 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 6 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 48 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 7 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 56 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU64 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU64 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/logic~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.xor - i64.const -1 - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $c i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $c - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $c - i64.add - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.mul - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.const 4294967296 - i64.or - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i32.add - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 2 - i64.const 32 - call $~lib/math/ipow64 - i64.add - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - i64.sub - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.mul - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i32.div_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i32.MIN_VALUE - i64.extend_i32_s - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i32.rem_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i32) - (local $a i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i32.const -1 - i32.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i32.MIN_VALUE - i32.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - i64.extend_i32_s - local.get $a - i64.extend_i32_s - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.div_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i64.MIN_VALUE - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|18 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.rem_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|19 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i64.MIN_VALUE - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|20 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperSigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|21 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperUnsigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|22 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperSignedUnsigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|23 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.lt_s - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|24 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.lt_u - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|25 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.gt_s - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|26 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.gt_u - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/instructions/outcome/status (param $result i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $result - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Result.HOST - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $id - call $assembly/instructions/outcome/OutcomeData#set:exitCode - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:a - call $assembly/instructions/outcome/hostCall - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#pop (param $this i32) (result i32) - (local $len i32) - (local $val i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - local.set $len - local.get $len - i32.const 1 - i32.lt_s - if - i32.const 11424 - i32.const 8128 - i32.const 271 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $len - i32.const 1 - i32.sub - local.tee $len - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $val - i32.store offset=4 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $len - call $~lib/array/Array#set:length_ - local.get $val - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/console/console.log (param $message i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $message - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/bindings/dom/console.log - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory-page/Arena#acquire (param $this i32) (result i32) - (local $allocatedMemory i32) - (local $data i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:free - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - i32.const 0 - i32.gt_s - if - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:free - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#pop - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.set $allocatedMemory - local.get $allocatedMemory - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/Arena#get:arenaBytes - i32.eq - if - i32.const 11472 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/console/console.log - end - global.get $~lib/memory/__stack_pointer - local.get $allocatedMemory - global.get $assembly/memory-page/ALLOCATE_EAGERLY - i32.lt_u - if (result i32) - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - else - i32.const 0 - end - local.tee $data - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - i32.const 1 - i32.add - call $assembly/memory-page/Arena#set:extraPageIndex - i32.const 0 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/RawPage#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) - (local $newBucketsCapacity i32) - (local $newBuckets i32) - (local $newEntriesCapacity i32) - (local $newEntries i32) - (local $oldPtr i32) - (local $oldEnd i32) - (local $newPtr i32) - (local $oldEntry i32) - (local $newEntry i32) - (local $oldEntryKey i32) - (local $newBucketIndex i32) - (local $newBucketPtrBase i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $newBucketsMask - i32.const 1 - i32.add - local.set $newBucketsCapacity - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newBucketsCapacity - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newBuckets - i32.store - local.get $newBucketsCapacity - i32.const 8 - i32.mul - i32.const 3 - i32.div_s - local.set $newEntriesCapacity - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newEntriesCapacity - block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.0" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newEntries - i32.store offset=4 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entries" - local.set $oldPtr - local.get $oldPtr - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.1" - end - i32.mul - i32.add - local.set $oldEnd - local.get $newEntries - local.set $newPtr - loop $while-continue|0 - local.get $oldPtr - local.get $oldEnd - i32.ne - if - local.get $oldPtr - local.set $oldEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $newPtr - local.set $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:key" - local.set $oldEntryKey - local.get $newEntry - local.get $oldEntryKey - call $"~lib/map/MapEntry#set:key" - local.get $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:value" - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/MapEntry#set:value" - local.get $oldEntryKey - call $~lib/util/hash/HASH - local.get $newBucketsMask - i32.and - local.set $newBucketIndex - local.get $newBuckets - local.get $newBucketIndex - i32.const 4 - i32.mul - i32.add - local.set $newBucketPtrBase - local.get $newEntry - local.get $newBucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $newBucketPtrBase - local.get $newPtr - i32.store - local.get $newPtr - block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.2" - end - i32.add - local.set $newPtr - end - local.get $oldPtr - block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.3" - end - i32.add - local.set $oldPtr - br $while-continue|0 - end - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBuckets - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBucketsMask - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntries - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntriesCapacity - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#get:entriesCount" - call $"~lib/map/Map#set:entriesOffset" - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) - (local $hashCode i32) - (local $entry i32) - (local $entries i32) - (local $6 i32) - (local $bucketPtrBase i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $key - call $~lib/util/hash/HASH - local.set $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $key - local.get $hashCode - call $"~lib/map/Map#find" - local.set $entry - local.get $entry - if - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.eq - if - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.const 3 - i32.mul - i32.const 4 - i32.div_s - i32.lt_s - if (result i32) - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.const 1 - i32.shl - i32.const 1 - i32.or - end - call $"~lib/map/Map#rehash" - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.tee $entries - i32.store offset=8 - local.get $entries - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.tee $6 - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesOffset" - local.get $6 - block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.4" - end - i32.mul - i32.add - local.set $entry - local.get $entry - local.get $key - call $"~lib/map/MapEntry#set:key" - i32.const 0 - drop - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - local.set $bucketPtrBase - local.get $entry - local.get $bucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $bucketPtrBase - local.get $entry - i32.store - end - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) - (local $freeMemoryStart i32) - (local $newSbrk i64) - (local $pageIdx i32) - (local $i i32) - (local $page i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $freeMemoryStart - i32.store - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $amount - i32.const 0 - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - local.get $amount - i64.extend_i32_u - i64.add - local.set $newSbrk - local.get $newSbrk - global.get $assembly/memory/MEMORY_SIZE - i64.ge_s - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Result#get:fault - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isFault - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $newSbrk - i32.wrap_i64 - call $assembly/memory/Memory#set:sbrkAddress - local.get $newSbrk - i64.const 1 - i64.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - local.set $pageIdx - local.get $pageIdx - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.const 1 - i32.add - local.set $i - loop $for-loop|0 - local.get $i - local.get $pageIdx - i32.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:arena - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=12 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory/Memory#get:pages - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $i - i32.const 0 - global.get $assembly/memory-page/Access.Write - local.get $page - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory-page/Page#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $"~lib/map/Map#set" - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $pageIdx - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#sbrk - local.tee $res - i32.store offset=12 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/mov~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_l - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_l_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/set~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.lt_u - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.lt_s - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.gt_u - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.gt_s - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_u - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/set~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_s - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/shift~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $imm i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $imm - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $imm - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $regValue i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $regValue - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regValue - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/typedarray/Uint8Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - i32.ge_u - if - i32.const 480 - i32.const 720 - i32.const 178 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $index - i32.add - local.get $value - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU8 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 1 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|0 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU16 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 2 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.gt_s - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $value - i32.const 65535 - i32.and - i32.const 8 - i32.const 15 - i32.and - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - else - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 65535 - i32.and - i32.const 8 - i32.const 15 - i32.and - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|1 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU32 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $v i32) - (local $len i32) - (local $i i32) - (local $i|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 4 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $value - local.set $v - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - local.get $v - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i32.const 8 - i32.shr_u - local.set $v - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i|7 - local.get $v - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i32.const 8 - i32.shr_u - local.set $v - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/instructions/store~anonymous|2 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#setU32 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU64 (param $this i32) (param $address i32) (param $value i64) (result i32) - (local $res i32) - (local $v i64) - (local $len i32) - (local $i i32) - (local $i|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 8 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $value - local.set $v - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - local.get $v - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i64.const 8 - i64.shr_u - local.set $v - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i|7 - local.get $v - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i64.const 8 - i64.shr_u - local.set $v - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/instructions/store~anonymous|3 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Memory#setU64 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/memory/Memory#setU32 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Memory#setU64 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/codec~anonymous|0 (param $firstByte i32) (result i32) - (local $len i32) - (local $i i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $assembly/codec/MASKS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.const 255 - i32.and - i32.lt_u - if - local.get $firstByte - i32.const 255 - i32.and - global.get $assembly/codec/MASKS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $i - call $~lib/array/Array#__get - i32.ge_u - if - i32.const 8 - local.get $i - i32.sub - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/Mask#isInstruction (param $this i32) (param $index i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - i64.extend_i32_u - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i64.extend_i32_s - i64.ge_u - if - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $index - call $~lib/staticarray/StaticArray#__get - i32.const 0 - i32.eq - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 14704 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/string/String#concat (param $this i32) (param $other i32) (result i32) - (local $thisSize i32) - (local $otherSize i32) - (local $outSize i32) - (local $out i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $thisSize - local.get $other - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $otherSize - local.get $thisSize - local.get $otherSize - i32.add - local.set $outSize - local.get $outSize - i32.const 0 - i32.eq - if - i32.const 14480 - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $out - local.get $this - local.get $thisSize - memory.copy - local.get $out - local.get $thisSize - i32.add - local.get $other - local.get $otherSize - memory.copy - local.get $out - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $~lib/string/String.__concat (param $left i32) (param $right i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $left - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $right - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/string/String#concat - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/util/string/joinStringArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $4 i32) - (local $estLen i32) - (local $value i32) - (local $i i32) - (local $offset i32) - (local $sepLen i32) - (local $result i32) - (local $i|11 i32) - (local $valueLen i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 14480 - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - end - local.get $lastIndex - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - i32.load - local.tee $4 - i32.store - local.get $4 - if (result i32) - local.get $4 - else - i32.const 14480 - end - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - end - i32.const 0 - local.set $estLen - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $i - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $estLen - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - i32.add - local.set $estLen - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $offset - local.get $separator - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - local.set $sepLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - local.get $sepLen - local.get $lastIndex - i32.mul - i32.add - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=12 - i32.const 0 - local.set $i|11 - loop $for-loop|1 - local.get $i|11 - local.get $lastIndex - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $i|11 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - local.set $valueLen - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value - local.get $valueLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $valueLen - i32.add - local.set $offset - end - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i|11 - i32.const 1 - i32.add - local.set $i|11 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $lastIndex - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - memory.copy - end - local.get $result - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - i32.const 1 - i32.lt_s - drop - i32.const 1 - drop - local.get $this - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/staticarray/StaticArray<~lib/string/String>#get:length - local.get $separator - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/util/string/joinStringArray - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/program/Mask#skipBytesToNextInstruction (param $this i32) (param $i i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $i - i32.const 1 - i32.add - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i32.lt_u - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $i - i32.const 1 - i32.add - call $~lib/staticarray/StaticArray#__get - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 14704 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/decodeArguments (param $kind i32) (param $data i32) (param $lim i32) (result i32) - (local $extended i32) - (local $i i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - global.get $assembly/arguments/REQUIRED_BYTES - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $kind - call $~lib/array/Array#__get - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/arguments/REQUIRED_BYTES - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $kind - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#constructor - local.tee $extended - i32.store offset=4 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $extended - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $extended - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $lim - i32.const 2 - global.set $~argumentsLength - global.get $assembly/arguments/DECODERS - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $kind - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $3) - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $lim - i32.const 2 - global.set $~argumentsLength - global.get $assembly/arguments/DECODERS - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $kind - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $3) - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/api-internal/getAssembly (param $p i32) (result i32) - (local $len i32) - (local $v i32) - (local $i i32) - (local $instruction i32) - (local $iData i32) - (local $6 i32) - (local $skipBytes i32) - (local $args i32) - (local $9 i32) - (local $argsArray i32) - (local $relevantArgs i32) - (local $i|12 i32) - (local $13 i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - local.get $len - i32.const 0 - i32.eq - if - i32.const 14400 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 14480 - local.tee $v - i32.store offset=8 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - call $assembly/program/Mask#isInstruction - i32.eqz - if - i32.const 14512 - i32.const 14624 - i32.const 48 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $instruction - call $~lib/array/Array#__get - end - local.set $iData - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const 14832 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - i32.const 10 - call $~lib/number/I32#toString - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 16640 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/string/String#concat - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $iData - call $assembly/instructions/Instruction#get:namePtr - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $~lib/memory/__stack_pointer - local.get $instruction - i32.const 10 - call $~lib/number/U8#toString - local.tee $6 - i32.store offset=20 - i32.const 16736 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 1 - local.get $6 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 16736 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 14480 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $i - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipBytes - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $p - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - local.get $i - i32.const 1 - i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $skipBytes - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - i32.const 38 - i32.const 0 - call $~lib/rt/__newArray - local.tee $9 - i32.store offset=28 - local.get $9 - i32.const 0 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:a - call $~lib/array/Array#__set - local.get $9 - i32.const 1 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:b - call $~lib/array/Array#__set - local.get $9 - i32.const 2 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:c - call $~lib/array/Array#__set - local.get $9 - i32.const 3 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/arguments/Args#get:d - call $~lib/array/Array#__set - local.get $9 - local.tee $argsArray - i32.store offset=32 - global.get $assembly/arguments/RELEVANT_ARGS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $iData - call $assembly/instructions/Instruction#get:kind - call $~lib/array/Array#__get - local.set $relevantArgs - i32.const 0 - local.set $i|12 - loop $for-loop|1 - local.get $i|12 - local.get $relevantArgs - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $~lib/memory/__stack_pointer - local.get $argsArray - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - local.get $i|12 - call $~lib/array/Array#__get - i32.const 10 - call $~lib/number/U32#toString - local.tee $13 - i32.store offset=36 - i32.const 16832 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 1 - local.get $13 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 16832 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - i32.const 14480 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=16 - local.get $14 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/string/String.__concat - local.tee $v - i32.store offset=8 - local.get $i|12 - i32.const 1 - i32.add - local.set $i|12 - br $for-loop|1 - end - end - local.get $i - local.get $skipBytes - i32.add - local.set $i - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $v - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program-build/skipBytes (param $kind i32) (param $data i32) (result i32) - (local $2 i32) - (local $n i32) - (local $split i32) - (local $n|5 i32) - (local $split|6 i32) - (local $n|7 i32) - (local $split|8 i32) - (local $value1 f64) - (local $value2 f64) - (local $value1|11 f64) - (local $value2|12 f64) - (local $n|13 i32) - (local $split|14 i32) - (local $15 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $case13|0 - block $case12|0 - block $case11|0 - block $case10|0 - block $case9|0 - block $case8|0 - block $case7|0 - block $case6|0 - block $case5|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $kind - local.set $2 - local.get $2 - global.get $assembly/arguments/Arguments.Zero - i32.eq - br_if $case0|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneImm - i32.eq - br_if $case1|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoImm - i32.eq - br_if $case2|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneOff - i32.eq - br_if $case3|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegOneImm - i32.eq - br_if $case4|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegOneExtImm - i32.eq - br_if $case5|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i32.eq - br_if $case6|0 - local.get $2 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i32.eq - br_if $case7|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoReg - i32.eq - br_if $case8|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i32.eq - br_if $case9|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i32.eq - br_if $case10|0 - local.get $2 - global.get $assembly/arguments/Arguments.TwoRegTwoImm - i32.eq - br_if $case11|0 - local.get $2 - global.get $assembly/arguments/Arguments.ThreeReg - i32.eq - br_if $case12|0 - br $case13|0 - end - i32.const 0 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - call $assembly/program-build/immBytes - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:low - i32.const 1 - i32.add - local.set $split - i32.const 1 - local.get $split - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - local.get $split - i32.const 1 - i32.add - i32.const 255 - i32.and - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - call $assembly/program-build/immBytes - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 9 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n|5 - i32.store offset=8 - local.get $n|5 - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:hig - i32.const 1 - i32.add - local.set $split|6 - i32.const 1 - local.get $split|6 - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - local.get $split|6 - i32.const 255 - i32.and - i32.add - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n|7 - i32.store offset=12 - local.get $n|7 - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:hig - i32.const 1 - i32.add - local.set $split|8 - i32.const 1 - local.get $split|8 - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - local.get $split|8 - i32.const 255 - i32.and - i32.add - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - block $~lib/math/NativeMath.min|inlined.5 (result f64) - f64.const 4 - local.set $value1 - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.5 - end - i32.trunc_sat_f64_s - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 1 - block $~lib/math/NativeMath.min|inlined.6 (result f64) - f64.const 4 - local.set $value1|11 - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - local.set $value2|12 - local.get $value1|11 - local.get $value2|12 - f64.min - br $~lib/math/NativeMath.min|inlined.6 - end - i32.trunc_sat_f64_s - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n|13 - i32.store offset=16 - local.get $n|13 - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $assembly/arguments/Nibbles#get:low - i32.const 1 - i32.add - local.set $split|14 - i32.const 2 - local.get $split|14 - i32.const 255 - i32.and - i32.add - local.get $data - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - call $~lib/typedarray/Uint8Array#get:length - i32.const 2 - local.get $split|14 - i32.const 255 - i32.and - i32.add - call $assembly/program-build/immBytes - i32.add - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 2 - local.set $15 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $15 - return - end - i32.const 16864 - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store - local.get $15 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString - local.set $15 - global.get $~lib/memory/__stack_pointer - local.get $15 - i32.store offset=20 - local.get $15 - call $~lib/string/String#concat - i32.const 16944 - i32.const 73 - i32.const 7 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 0 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/program-build/buildMask (param $bytecode i32) (result i32) - (local $mask i32) - (local $i i32) - (local $instruction i32) - (local $iData i32) - (local $requiredBytes i32) - (local $6 i32) - (local $packed i32) - (local $i|8 i32) - (local $byte i32) - (local $j i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - call $~lib/staticarray/StaticArray#constructor - local.tee $mask - i32.store offset=4 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/array/Array#get:length - i32.lt_s - if (result i32) - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $instruction - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION - end - local.set $iData - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $i - i32.const 1 - call $~lib/staticarray/StaticArray#__set - global.get $assembly/arguments/REQUIRED_BYTES - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $iData - call $assembly/instructions/Instruction#get:kind - call $~lib/array/Array#__get - local.set $requiredBytes - local.get $i - i32.const 1 - i32.add - local.get $requiredBytes - i32.add - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - i32.le_s - if - local.get $i - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $bytecode - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - local.get $i - i32.const 1 - i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $assembly/program-build/skipBytes - i32.add - local.set $i - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 17024 - call $~lib/rt/__newArray - local.tee $packed - i32.store offset=12 - i32.const 0 - local.set $i|8 - loop $for-loop|1 - local.get $i|8 - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - i32.const 0 - local.set $byte - local.get $i|8 - local.set $j - loop $for-loop|3 - local.get $j - local.get $i|8 - i32.const 8 - i32.add - i32.lt_s - if - local.get $byte - i32.const 255 - i32.and - i32.const 1 - i32.const 7 - i32.and - i32.shr_u - local.set $byte - local.get $j - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if (result i32) - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $j - call $~lib/staticarray/StaticArray#__get - else - i32.const 0 - end - if - local.get $byte - i32.const 128 - i32.or - local.set $byte - end - local.get $j - i32.const 1 - i32.add - local.set $j - br $for-loop|3 - end - end - local.get $packed - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - local.get $byte - call $~lib/array/Array#push - drop - local.get $i|8 - i32.const 8 - i32.add - local.set $i|8 - br $for-loop|1 - end - end - local.get $packed - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/dataview/DataView#constructor (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) - (local $dataStart i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 40 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/dataview/DataView#set:buffer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/dataview/DataView#set:dataStart - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/dataview/DataView#set:byteLength - local.get $byteLength - i32.const 1073741820 - i32.gt_u - local.get $byteOffset - local.get $byteLength - i32.add - local.get $buffer - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/arraybuffer/ArrayBuffer#get:byteLength - i32.gt_u - i32.or - if - i32.const 8176 - i32.const 17056 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $buffer - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/dataview/DataView#set:buffer - local.get $buffer - local.get $byteOffset - i32.add - local.set $dataStart - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $dataStart - call $~lib/dataview/DataView#set:dataStart - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $byteLength - call $~lib/dataview/DataView#set:byteLength - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $~lib/dataview/DataView#constructor@varargs (param $this i32) (param $buffer i32) (param $byteOffset i32) (param $byteLength i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $byteOffset - end - local.get $buffer - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/arraybuffer/ArrayBuffer#get:byteLength - local.set $byteLength - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $buffer - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $byteOffset - local.get $byteLength - call $~lib/dataview/DataView#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/dataview/DataView#setUint64 (param $this i32) (param $byteOffset i32) (param $value i64) (param $littleEndian i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $byteOffset - i32.const 31 - i32.shr_u - local.get $byteOffset - i32.const 8 - i32.add - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/dataview/DataView#get:byteLength - i32.gt_s - i32.or - if - i32.const 480 - i32.const 17056 - i32.const 174 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/dataview/DataView#get:dataStart - local.get $byteOffset - i32.add - local.get $littleEndian - if (result i64) - local.get $value - else - local.get $value - call $~lib/polyfills/bswap - end - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/encodeVarU32 (param $v i64) (result i32) - (local $maxEncoded i64) - (local $dest i32) - (local $dataView i32) - (local $minEncoded i64) - (local $l i32) - (local $dest|6 i32) - (local $maxVal i32) - (local $byte i64) - (local $rest i64) - (local $i i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - local.get $v - i64.const 0 - i64.eq - if - i32.const 0 - i32.const 1 - call $~lib/typedarray/Uint8Array#constructor - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - i64.const 2 - i64.const 7 - i64.const 8 - i64.mul - call $~lib/math/ipow64 - local.set $maxEncoded - local.get $v - local.get $maxEncoded - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 9 - call $~lib/typedarray/Uint8Array#constructor - local.tee $dest - i32.store - local.get $dest - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - i32.const 255 - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $dest - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/dataview/DataView#constructor@varargs - local.tee $dataView - i32.store offset=12 - local.get $dataView - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 1 - local.get $v - i32.const 1 - call $~lib/dataview/DataView#setUint64 - local.get $dest - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $maxEncoded - i64.const 7 - i64.shr_u - local.set $minEncoded - i32.const 7 - local.set $l - loop $for-loop|0 - local.get $l - i32.const 0 - i32.ge_s - if - local.get $v - local.get $minEncoded - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $l - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $dest|6 - i32.store offset=16 - i32.const 2 - i32.const 8 - local.get $l - i32.mul - call $~lib/math/ipow32 - local.set $maxVal - i32.const 2 - i32.const 8 - call $~lib/math/ipow32 - i32.const 2 - i32.const 8 - local.get $l - i32.sub - call $~lib/math/ipow32 - i32.sub - i64.extend_i32_s - local.get $v - local.get $maxVal - i64.extend_i32_s - i64.div_u - i64.add - local.set $byte - local.get $dest|6 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - local.get $byte - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - local.get $maxVal - i64.extend_i32_s - i64.rem_u - local.set $rest - i32.const 1 - local.set $i - loop $for-loop|1 - local.get $i - i32.const 1 - local.get $l - i32.add - i32.lt_s - if - local.get $dest|6 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $i - local.get $rest - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $rest - i64.const 8 - i64.shr_u - local.set $rest - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|1 - end - end - local.get $dest|6 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $minEncoded - local.set $maxEncoded - local.get $minEncoded - i64.const 7 - i64.shr_u - local.set $minEncoded - local.get $l - i32.const 1 - i32.sub - local.set $l - br $for-loop|0 - end - end - i32.const 17120 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $v - i32.const 10 - call $~lib/number/U64#toString - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/string/String#concat - i32.const 17200 - i32.const 160 - i32.const 3 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/program-build/wrapAsProgram (param $bytecode i32) (result i32) - (local $codeLength i32) - (local $mask i32) - (local $codeLengthBytes i32) - (local $data i32) - (local $offset i32) - (local $i i32) - (local $i|7 i32) - (local $i|8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - local.get $bytecode - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.set $codeLength - global.get $~lib/memory/__stack_pointer - local.get $bytecode - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $assembly/program-build/buildMask - local.tee $mask - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $codeLength - i64.extend_i32_s - call $assembly/codec/encodeVarU32 - local.tee $codeLengthBytes - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 1 - i32.add - local.get $codeLengthBytes - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.add - local.get $codeLength - i32.add - local.get $mask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $data - i32.store offset=12 - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set - i32.const 2 - local.set $offset - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $codeLengthBytes - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $offset - local.get $codeLengthBytes - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $offset - i32.const 1 - i32.add - local.set $offset - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $bytecode - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $offset - local.get $bytecode - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - local.get $i|7 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $offset - i32.const 1 - i32.add - local.set $offset - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - i32.const 0 - local.set $i|8 - loop $for-loop|2 - local.get $i|8 - local.get $mask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.lt_s - if - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $offset - local.get $mask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - local.get $i|8 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $offset - i32.const 1 - i32.add - local.set $offset - local.get $i|8 - i32.const 1 - i32.add - local.set $i|8 - br $for-loop|2 - end - end - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/array/Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/array/Array#get:dataStart - local.set $sourceStart - i32.const 0 - i32.eqz - drop - local.get $targetStart - local.get $sourceStart - local.get $sourceLen - i32.const 0 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/liftBytes (param $data i32) (result i32) - (local $p i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $p - i32.store offset=4 - local.get $p - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#set<~lib/array/Array> - local.get $p - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#constructor (param $this i32) (param $source i32) (param $offset i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 42 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $source - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/codec/Decoder#set:source - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $offset - call $assembly/codec/Decoder#set:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/codec/Decoder#ensureBytes (param $this i32) (param $need i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#get:offset - local.get $need - i32.add - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/codec/Decoder#get:source - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $need - i32.const 10 - call $~lib/number/U32#toString - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/codec/Decoder#get:source - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#get:offset - i32.sub - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=12 - i32.const 17392 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $2 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 17392 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 3 - local.get $3 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 17392 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 14480 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 17200 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/ValOffset#constructor (param $this i32) (param $value i32) (param $offset i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 43 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $value - call $assembly/codec/ValOffset#set:value - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $offset - call $assembly/codec/ValOffset#set:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/codec/decodeVarU32 (param $data i32) (result i32) - (local $length i32) - (local $first i32) - (local $3 i32) - (local $4 i32) - (local $msb i32) - (local $number i32) - (local $i i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - i32.const 1 - global.set $~argumentsLength - global.get $assembly/codec/variableLength - i32.load - call_indirect (type $0) - i32.const 255 - i32.and - local.set $length - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $first - local.get $length - i32.const 0 - i32.eq - if - i32.const 0 - local.get $first - i32.const 1 - call $assembly/codec/ValOffset#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.get $length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.const 10 - call $~lib/number/I32#toString - local.tee $4 - i32.store offset=8 - i32.const 17600 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $3 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 17600 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 3 - local.get $4 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 17600 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 14480 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 17200 - i32.const 108 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $first - i32.const 2 - i32.const 8 - local.get $length - i32.sub - call $~lib/math/ipow32 - i32.add - i32.const 2 - i32.const 8 - call $~lib/math/ipow32 - i32.sub - local.get $length - i32.const 8 - i32.mul - i32.shl - local.set $msb - i32.const 0 - local.set $number - local.get $length - i32.const 1 - i32.sub - local.set $i - loop $for-loop|0 - local.get $i - i32.const 0 - i32.ge_s - if - local.get $number - i32.const 8 - i32.shl - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $i - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.add - local.set $number - local.get $i - i32.const 1 - i32.sub - local.set $i - br $for-loop|0 - end - end - local.get $number - local.get $msb - i32.add - local.set $number - i32.const 0 - local.get $number - i32.const 1 - local.get $length - i32.add - call $assembly/codec/ValOffset#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/codec/Decoder#varU32 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/decodeVarU32 - local.tee $v - i32.store offset=12 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/ValOffset#get:offset - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/ValOffset#get:value - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#bytes (param $this i32) (param $len i32) (result i32) - (local $v i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $len - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:source - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $len - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $v - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $len - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/codec/Decoder#remainingBytes (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $v - i32.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/typedarray/Uint8Array#get:length - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/program/CodeAndMetadata#constructor (param $this i32) (param $code i32) (param $metadata i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 41 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $code - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/program/CodeAndMetadata#set:code - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $metadata - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/program/CodeAndMetadata#set:metadata - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/program/extractCodeAndMetadata (param $data i32) (result i32) - (local $decoder i32) - (local $metadataLength i32) - (local $metadata i32) - (local $code i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=4 - local.get $decoder - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/codec/Decoder#varU32 - local.set $metadataLength - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $metadataLength - call $assembly/codec/Decoder#bytes - local.tee $metadata - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/codec/Decoder#remainingBytes - local.tee $code - i32.store offset=12 - i32.const 0 - local.get $code - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $metadata - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/program/CodeAndMetadata#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/codec/Decoder#u24 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 3 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 3 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u16 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 2 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.const 15 - i32.and - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u32 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 4 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 3 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 4 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#isExhausted (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#get:offset - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $assembly/codec/Decoder#get:source - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - i32.ge_s - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $assembly/codec/Decoder#finish (param $this i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - i32.const 17904 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - call $assembly/codec/Decoder#get:source - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/codec/Decoder#get:offset - i32.sub - i32.const 10 - call $~lib/number/I32#toString - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/string/String#concat - i32.const 17200 - i32.const 31 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/Decoder#u8 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/Mask#constructor (param $this i32) (param $packedMask i32) (param $codeLength i32) (result i32) - (local $lastInstructionOffset i32) - (local $i i32) - (local $bits i32) - (local $index i32) - (local $b i32) - (local $isSet i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 31 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - call $assembly/program/Mask#set:bytesToSkip - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - local.get $codeLength - call $~lib/staticarray/StaticArray#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/Mask#set:bytesToSkip - i32.const 0 - local.set $lastInstructionOffset - local.get $packedMask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.sub - local.set $i - loop $for-loop|0 - local.get $i - i32.const 0 - i32.ge_s - if - local.get $packedMask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $bits - local.get $i - i32.const 8 - i32.mul - local.set $index - i32.const 7 - local.set $b - loop $for-loop|2 - local.get $b - i32.const 0 - i32.ge_s - if - local.get $bits - i32.const 128 - i32.and - local.set $isSet - local.get $bits - i32.const 1 - i32.const 7 - i32.and - i32.shl - local.set $bits - local.get $index - local.get $b - i32.add - local.get $codeLength - i32.lt_s - if - local.get $isSet - if (result i32) - i32.const 0 - else - local.get $lastInstructionOffset - i32.const 1 - i32.add - end - local.set $lastInstructionOffset - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/Mask#get:bytesToSkip - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $index - local.get $b - i32.add - local.get $lastInstructionOffset - global.get $assembly/program/MAX_SKIP - i32.const 1 - i32.add - i32.lt_u - if (result i32) - local.get $lastInstructionOffset - else - global.get $assembly/program/MAX_SKIP - i32.const 1 - i32.add - end - call $~lib/staticarray/StaticArray#__set - end - local.get $b - i32.const 1 - i32.sub - local.set $b - br $for-loop|2 - end - end - local.get $i - i32.const 1 - i32.sub - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - ) - (func $assembly/program/JumpTable#constructor (param $this i32) (param $itemBytes i32) (param $data i32) (result i32) - (local $jumps i32) - (local $i i32) - (local $num i64) - (local $j i32) - (local $nextNum i64) - (local $isOverflow i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 33 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - call $assembly/program/JumpTable#set:jumps - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $itemBytes - i32.const 255 - i32.and - i32.const 0 - i32.gt_u - if (result i32) - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.get $itemBytes - i32.const 255 - i32.and - i32.div_s - else - i32.const 0 - end - call $~lib/staticarray/StaticArray#constructor - local.tee $jumps - i32.store offset=8 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - i64.const 0 - local.set $num - local.get $itemBytes - i32.const 1 - i32.sub - i32.const 255 - i32.and - local.set $j - loop $for-loop|1 - local.get $j - i32.const 0 - i32.ge_s - if - local.get $num - i64.const 8 - i64.shl - local.set $nextNum - local.get $nextNum - local.get $num - i64.lt_u - local.set $isOverflow - local.get $nextNum - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - local.get $j - i32.add - call $~lib/typedarray/Uint8Array#__get - i64.extend_i32_u - i64.add - local.set $nextNum - local.get $isOverflow - if (result i32) - i32.const 1 - else - local.get $nextNum - local.get $num - i64.lt_u - end - local.set $isOverflow - local.get $isOverflow - if (result i64) - global.get $~lib/builtins/u64.MAX_VALUE - else - local.get $nextNum - end - local.set $num - local.get $j - i32.const 1 - i32.sub - local.set $j - br $for-loop|1 - end - end - local.get $jumps - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - local.get $itemBytes - i32.const 255 - i32.and - i32.div_s - local.get $num - call $~lib/staticarray/StaticArray#__set - local.get $i - local.get $itemBytes - i32.const 255 - i32.and - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $jumps - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $assembly/program/JumpTable#set:jumps - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 8288 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/BasicBlocks#constructor (param $this i32) (param $code i32) (param $mask i32) (result i32) - (local $len i32) - (local $isStartOrEnd i32) - (local $n i32) - (local $isInstructionInMask i32) - (local $skipArgs i32) - (local $iData i32) - (local $isTerminating i32) - (local $newBlockStart i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 34 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - call $assembly/program/BasicBlocks#set:isStartOrEnd - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $len - call $~lib/staticarray/StaticArray#constructor - local.tee $isStartOrEnd - i32.store offset=8 - local.get $len - i32.const 0 - i32.gt_s - if - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set - end - i32.const 0 - local.set $n - loop $for-loop|0 - local.get $n - local.get $len - i32.lt_s - if - block $for-continue|0 - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $assembly/program/Mask#isInstruction - local.set $isInstructionInMask - local.get $isInstructionInMask - i32.eqz - if - br $for-continue|0 - end - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipArgs - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#__get - end - local.set $iData - local.get $iData - call $assembly/instructions/Instruction#get:isTerminating - local.set $isTerminating - local.get $isTerminating - if - local.get $n - i32.const 1 - i32.add - local.get $skipArgs - i32.add - local.set $newBlockStart - local.get $newBlockStart - local.get $len - i32.lt_s - if - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $newBlockStart - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set - end - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - local.get $n - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.END - i32.or - call $~lib/staticarray/StaticArray#__set - end - end - local.get $n - i32.const 1 - i32.add - local.set $n - br $for-loop|0 - end - end - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - call $assembly/program/BasicBlocks#set:isStartOrEnd - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - ) - (func $assembly/program/Program#constructor (param $this i32) (param $code i32) (param $mask i32) (param $jumpTable i32) (param $basicBlocks i32) (result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 30 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $code - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:code - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:mask - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:jumpTable - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:basicBlocks - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/program/deblob (param $program i32) (result i32) - (local $decoder i32) - (local $jumpTableLength i32) - (local $jumpTableItemLength i32) - (local $codeLength i32) - (local $jumpTableLengthInBytes i32) - (local $rawJumpTable i32) - (local $rawCode i32) - (local $rawMask i32) - (local $mask i32) - (local $jumpTable i32) - (local $basicBlocks i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $program - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=4 - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#varU32 - local.set $jumpTableLength - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#u8 - local.set $jumpTableItemLength - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#varU32 - local.set $codeLength - local.get $jumpTableLength - local.get $jumpTableItemLength - i32.mul - local.set $jumpTableLengthInBytes - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $jumpTableLengthInBytes - call $assembly/codec/Decoder#bytes - local.tee $rawJumpTable - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - call $assembly/codec/Decoder#bytes - local.tee $rawCode - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - i32.const 7 - i32.add - i32.const 8 - i32.div_u - call $assembly/codec/Decoder#bytes - local.tee $rawMask - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $rawMask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $jumpTableItemLength - local.get $rawJumpTable - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/program/JumpTable#constructor - local.tee $jumpTable - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $rawCode - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $mask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - call $assembly/program/BasicBlocks#constructor - local.tee $basicBlocks - i32.store offset=32 - i32.const 0 - local.get $rawCode - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $mask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - local.get $jumpTable - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=36 - local.get $12 - local.get $basicBlocks - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=40 - local.get $12 - call $assembly/program/Program#constructor - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $"~lib/map/Map#constructor" (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.const 18 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 4 - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - i32.const 1 - i32.sub - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 4 - block $"~lib/map/ENTRY_SIZE|inlined.5" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.5" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesOffset" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/typedarray/Uint8Array.wrap (param $buffer i32) (param $byteOffset i32) (param $length i32) (result i32) - (local $buffer|3 i32) - (local $byteOffset|4 i32) - (local $len i32) - (local $byteLength i32) - (local $bufferByteLength i32) - (local $out i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - block $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $buffer - local.tee $buffer|3 - i32.store - local.get $byteOffset - local.set $byteOffset|4 - local.get $length - local.set $len - local.get $buffer|3 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/arraybuffer/ArrayBuffer#get:byteLength - local.set $bufferByteLength - local.get $byteOffset|4 - local.get $bufferByteLength - i32.gt_u - local.get $byteOffset|4 - i32.const 0 - i32.and - i32.or - if - i32.const 480 - i32.const 720 - i32.const 1860 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $len - i32.const 0 - i32.lt_s - if - local.get $len - i32.const -1 - i32.eq - if - local.get $bufferByteLength - i32.const 0 - i32.and - if - i32.const 8176 - i32.const 720 - i32.const 1865 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - local.get $bufferByteLength - local.get $byteOffset|4 - i32.sub - local.set $byteLength - else - i32.const 8176 - i32.const 720 - i32.const 1869 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - else - local.get $len - i32.const 0 - i32.shl - local.set $byteLength - local.get $byteOffset|4 - local.get $byteLength - i32.add - local.get $bufferByteLength - i32.gt_s - if - i32.const 8176 - i32.const 720 - i32.const 1874 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=8 - local.get $out - local.get $buffer|3 - i32.store - local.get $out - local.get $buffer|3 - i32.const 0 - call $~lib/rt/itcms/__link - local.get $out - local.get $byteLength - i32.store offset=8 - local.get $out - local.get $buffer|3 - local.get $byteOffset|4 - i32.add - i32.store offset=4 - local.get $out - br $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" - end - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $~lib/array/Array#unshift (param $this i32) (param $value i32) (result i32) - (local $len i32) - (local $ptr i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.set $ptr - local.get $ptr - i32.const 4 - i32.add - local.get $ptr - local.get $len - i32.const 1 - i32.sub - i32.const 2 - i32.shl - memory.copy - local.get $ptr - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory-page/Arena#constructor (param $this i32) (param $pageCount i32) (result i32) - (local $2 i32) - (local $data i32) - (local $i i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 16 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:free - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:arenaBytes - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:extraPageIndex - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/memory-page/PAGE_SIZE - local.get $pageCount - i32.mul - call $assembly/memory-page/Arena#set:arenaBytes - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - i32.const 2 - i32.const 17 - i32.const 18032 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory-page/Arena#set:free - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pageCount - call $assembly/memory-page/Arena#set:extraPageIndex - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory-page/Arena#get:arenaBytes - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $data - i32.store offset=12 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pageCount - i32.lt_s - if - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory-page/Arena#get:free - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - local.get $i - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array.wrap - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory-page/RawPage#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/array/Array#unshift - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/memory/MemoryBuilder#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 45 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#constructor" - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/MemoryBuilder#set:pages - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 128 - call $assembly/memory-page/Arena#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/MemoryBuilder#set:arena - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/memory/MemoryBuilder#getOrCreatePageForAddress (param $this i32) (param $access i32) (param $address i32) (result i32) - (local $pageIdx i32) - (local $page i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $address - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $pageIdx - local.get $pageIdx - global.get $assembly/memory-page/RESERVED_PAGES - i32.lt_u - if - i32.const 18064 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - i32.const 10 - call $~lib/number/U32#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/string/String#concat - i32.const 18160 - i32.const 93 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/MemoryBuilder#get:pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/MemoryBuilder#get:arena - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=8 - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/MemoryBuilder#get:pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - i32.const 0 - local.get $access - local.get $page - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory-page/Page#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $"~lib/map/Map#set" - drop - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/MemoryBuilder#get:pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - call $"~lib/map/Map#get" - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.set $sourceStart - i32.const 0 - i32.eqz - drop - local.get $targetStart - local.get $sourceStart - local.get $sourceLen - i32.const 0 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MemoryBuilder#setData (param $this i32) (param $access i32) (param $address i32) (param $data i32) (result i32) - (local $currentAddress i32) - (local $currentData i32) - (local $page i32) - (local $relAddress i32) - (local $spaceInPage i32) - (local $end i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $address - local.set $currentAddress - global.get $~lib/memory/__stack_pointer - local.get $data - local.tee $currentData - i32.store - loop $while-continue|0 - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $access - local.get $currentAddress - call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress - local.tee $page - i32.store offset=8 - local.get $currentAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.rem_u - local.set $relAddress - global.get $assembly/memory-page/PAGE_SIZE - local.get $relAddress - i32.sub - local.set $spaceInPage - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - local.get $spaceInPage - i32.lt_u - if (result i32) - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - else - local.get $spaceInPage - end - local.set $end - local.get $page - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $10 - call $assembly/memory-page/Page#get:raw - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - call $assembly/memory-page/RawPage#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - i32.const 0 - local.get $end - call $~lib/typedarray/Uint8Array#subarray - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - local.get $relAddress - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $currentAddress - local.get $end - i32.add - local.set $currentAddress - global.get $~lib/memory/__stack_pointer - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $end - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $currentData - i32.store - br $while-continue|0 - end - end - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $assembly/memory/MemoryBuilder#setEmpty (param $this i32) (param $access i32) (param $address i32) (param $len i32) (result i32) - (local $endAddress i32) - (local $currentAddress i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $address - local.get $len - i32.add - local.set $endAddress - local.get $address - local.set $currentAddress - loop $for-loop|0 - local.get $currentAddress - local.get $endAddress - i32.lt_u - if - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $access - local.get $currentAddress - call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress - drop - local.get $currentAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.add - local.set $currentAddress - br $for-loop|0 - end - end - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/memory/Memory#constructor (param $this i32) (param $arena i32) (param $pages i32) (param $sbrkAddress i32) (result i32) - (local $sbrkPage i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 15 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $arena - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory/Memory#set:arena - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory/Memory#set:pages - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $sbrkAddress - call $assembly/memory/Memory#set:sbrkAddress - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $sbrkAddress - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $sbrkPage - local.get $sbrkPage - global.get $assembly/memory-page/RESERVED_PAGES - i32.lt_u - if - i32.const 18224 - i32.const 18160 - i32.const 119 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $sbrkPage - call $"~lib/map/Map#has" - if (result i32) - local.get $sbrkPage - else - local.get $sbrkPage - i32.const 1 - i32.sub - end - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/memory/MemoryBuilder#build (param $this i32) (param $sbrkAddress i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - i32.const 0 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MemoryBuilder#get:arena - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MemoryBuilder#get:pages - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $sbrkAddress - call $assembly/memory/Memory#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/spi/StandardProgram#constructor (param $this i32) (param $program i32) (param $memory i32) (param $registers i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 44 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:program - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:memory - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:registers - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:metadata - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/spi/StandardProgram#set:pc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i64.const 0 - call $assembly/spi/StandardProgram#set:gas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/spi/decodeSpi (param $data i32) (param $args i32) (result i32) - (local $argsLength i32) - (local $3 i32) - (local $4 i32) - (local $decoder i32) - (local $roLength i32) - (local $rwLength i32) - (local $heapPages i32) - (local $stackSize i32) - (local $roMem i32) - (local $rwMem i32) - (local $codeLength i32) - (local $code i32) - (local $program i32) - (local $builder i32) - (local $heapStart i32) - (local $heapZerosStart i32) - (local $heapZerosLength i32) - (local $heapZerosEnd i32) - (local $stackLength i32) - (local $stackStart i32) - (local $memory i32) - (local $registers i32) - (local $24 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $args - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $~lib/typedarray/Uint8Array#get:length - local.set $argsLength - local.get $argsLength - global.get $assembly/spi/MAX_ARGS_LEN - i32.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $argsLength - i32.const 10 - call $~lib/number/U32#toString - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - global.get $assembly/spi/MAX_ARGS_LEN - i32.const 10 - call $~lib/number/U32#toString - local.tee $4 - i32.store offset=8 - i32.const 17792 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 1 - local.get $3 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 17792 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 3 - local.get $4 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 17792 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 14480 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 17840 - i32.const 18 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=16 - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#u24 - local.set $roLength - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#u24 - local.set $rwLength - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#u16 - local.set $heapPages - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#u24 - local.set $stackSize - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - local.get $roLength - call $assembly/codec/Decoder#bytes - local.tee $roMem - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - local.get $rwLength - call $assembly/codec/Decoder#bytes - local.tee $rwMem - i32.store offset=24 - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#u32 - local.set $codeLength - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - local.get $codeLength - call $assembly/codec/Decoder#bytes - local.tee $code - i32.store offset=28 - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#finish - global.get $~lib/memory/__stack_pointer - local.get $code - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/program/deblob - local.tee $program - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store offset=36 - i32.const 2 - global.get $assembly/memory-page/SEGMENT_SIZE - i32.mul - local.get $roLength - call $assembly/spi/alignToSegmentSize - i32.add - local.set $heapStart - local.get $heapStart - local.get $rwLength - call $assembly/spi/alignToPageSize - i32.add - local.set $heapZerosStart - local.get $heapPages - i32.const 65535 - i32.and - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.set $heapZerosLength - local.get $heapZerosStart - local.get $heapZerosLength - i32.add - local.set $heapZerosEnd - local.get $stackSize - call $assembly/spi/alignToPageSize - local.set $stackLength - global.get $assembly/spi/STACK_SEGMENT_END - local.get $stackLength - i32.sub - local.set $stackStart - local.get $roLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - global.get $assembly/memory-page/Access.Read - global.get $assembly/memory-page/SEGMENT_SIZE - local.get $roMem - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $assembly/memory/MemoryBuilder#setData - drop - end - local.get $argsLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - global.get $assembly/memory-page/Access.Read - global.get $assembly/spi/ARGS_SEGMENT_START - local.get $args - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $assembly/memory/MemoryBuilder#setData - drop - end - local.get $rwLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - global.get $assembly/memory-page/Access.Write - local.get $heapStart - local.get $rwMem - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $assembly/memory/MemoryBuilder#setData - drop - end - local.get $heapZerosLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - global.get $assembly/memory-page/Access.Write - local.get $heapZerosStart - local.get $heapZerosLength - call $assembly/memory/MemoryBuilder#setEmpty - drop - end - local.get $stackLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - global.get $assembly/memory-page/Access.Write - local.get $stackStart - local.get $stackLength - call $assembly/memory/MemoryBuilder#setEmpty - drop - end - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - local.get $heapZerosEnd - call $assembly/memory/MemoryBuilder#build - local.tee $memory - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=44 - local.get $registers - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 0 - i64.const 4294901760 - call $~lib/staticarray/StaticArray#__set - local.get $registers - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 1 - global.get $assembly/spi/STACK_SEGMENT_END - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - local.get $registers - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 7 - global.get $assembly/spi/ARGS_SEGMENT_START - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - local.get $registers - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 8 - local.get $argsLength - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - i32.const 0 - local.get $program - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - local.get $memory - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - local.get $registers - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=48 - local.get $24 - call $assembly/spi/StandardProgram#constructor - local.set $24 - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $24 - return - ) - (func $assembly/gas/GasCounterU64#constructor (param $this i32) (param $gas i64) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 46 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $gas - call $assembly/gas/GasCounterU64#set:gas - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/interpreter/Interpreter#constructor (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 33 - i32.const 29 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:program - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:registers - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:memory - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:gas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:pc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:exitCode - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:nextPc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:useSbrkGas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/interpreter/Interpreter#set:program - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/interpreter/Interpreter#set:registers - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/interpreter/Interpreter#set:memory - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i64.const 0 - call $assembly/gas/gasCounter - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/interpreter/Interpreter#set:gas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:pc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - global.get $assembly/interpreter/Status.OK - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const -1 - call $assembly/interpreter/Interpreter#set:exitCode - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:nextPc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/interpreter/Interpreter#set:useSbrkGas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $bufferSize i32) - (local $buffer i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 47 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:length_ - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8128 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - local.tee $2 - i32.const 8 - local.tee $3 - local.get $2 - local.get $3 - i32.gt_u - select - i32.const 2 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $bufferSize - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $length - call $~lib/array/Array#set:length_ - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.get $newLength - i32.const 2 - i32.const 0 - call $~lib/array/ensureCapacity - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $newLength - call $~lib/array/Array#set:length_ - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#values" (param $this i32) (result i32) - (local $start i32) - (local $size i32) - (local $values i32) - (local $length i32) - (local $i i32) - (local $entry i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.set $start - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.set $size - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $size - call $~lib/array/Array#constructor - local.tee $values - i32.store offset=4 - i32.const 0 - local.set $length - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $size - i32.lt_s - if - local.get $start - local.get $i - block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.6" - end - i32.mul - i32.add - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - local.tee $7 - i32.const 1 - i32.add - local.set $length - local.get $7 - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/array/Array#__set - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - call $~lib/array/Array#set:length - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 14704 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory-page/Arena#release (param $this i32) (param $page i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory-page/Arena#get:free - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $page - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/array/Array#push - drop - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#clear" (param $this i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - i32.const 4 - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 4 - i32.const 1 - i32.sub - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - i32.const 4 - block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.7" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 4 - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesOffset" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesCount" - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#free (param $this i32) - (local $pages i32) - (local $i i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory/Memory#get:pages - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $"~lib/map/Map#values" - local.tee $pages - i32.store offset=8 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pages - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - i32.lt_s - if - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/memory/Memory#get:arena - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $pages - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $3 - local.get $i - call $~lib/array/Array#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/memory-page/Page#get:raw - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#release - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory/Memory#get:pages - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $"~lib/map/Map#clear" - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/resetJAM (param $program i32) (param $pc f64) (param $initialGas i64) (param $args i32) (param $hasMetadata i32) - (local $code i32) - (local $p i32) - (local $int i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $hasMetadata - if (result i32) - local.get $program - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/liftBytes - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/program/extractCodeAndMetadata - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $assembly/program/CodeAndMetadata#get:code - else - local.get $program - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $assembly/program/liftBytes - end - local.tee $code - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $code - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $args - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/liftBytes - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/spi/decodeSpi - local.tee $p - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $p - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=20 - local.get $9 - call $assembly/spi/StandardProgram#get:program - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $p - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=20 - local.get $9 - call $assembly/spi/StandardProgram#get:registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $p - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=20 - local.get $9 - call $assembly/spi/StandardProgram#get:memory - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/interpreter/Interpreter#constructor - local.tee $int - i32.store offset=24 - local.get $int - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $pc - i32.trunc_sat_f64_u - call $assembly/interpreter/Interpreter#set:nextPc - local.get $int - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/interpreter/Interpreter#get:gas - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $initialGas - call $assembly/gas/GasCounter#set@override - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $8 - i32.store offset=28 - local.get $8 - if (result i32) - local.get $8 - else - i32.const 9488 - i32.const 18336 - i32.const 22 - i32.const 19 - call $~lib/builtins/abort - unreachable - end - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/interpreter/Interpreter#get:memory - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $assembly/memory/Memory#free - end - local.get $int - global.set $assembly/api-debugger/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/resetJAM@varargs (param $program i32) (param $pc f64) (param $initialGas i64) (param $args i32) (param $hasMetadata i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 4 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - i32.const 0 - local.set $hasMetadata - end - local.get $program - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pc - local.get $initialGas - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $hasMetadata - call $assembly/api-debugger/resetJAM - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/fillRegisters (param $registers i32) (param $flat i32) - (local $len i32) - (local $3 i32) - (local $4 i32) - (local $i i32) - (local $num i64) - (local $j i32) - (local $index i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/staticarray/StaticArray#get:length - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - local.set $len - local.get $len - local.get $flat - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.ne - if - global.get $~lib/memory/__stack_pointer - local.get $flat - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/array/Array#get:length - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $len - i32.const 10 - call $~lib/number/I32#toString - local.tee $4 - i32.store offset=8 - i32.const 18560 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 1 - local.get $3 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18560 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 3 - local.get $4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 18560 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 14480 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 18336 - i32.const 221 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - i64.const 0 - local.set $num - i32.const 0 - local.set $j - loop $for-loop|1 - local.get $j - global.get $assembly/registers/REG_SIZE_BYTES - i32.const 255 - i32.and - i32.lt_u - if - local.get $i - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - local.get $j - i32.add - local.set $index - local.get $num - local.get $flat - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $index - call $~lib/array/Array#__get - i64.extend_i32_u - local.get $j - i32.const 8 - i32.mul - i32.const 255 - i32.and - i64.extend_i32_u - i64.shl - i64.or - local.set $num - local.get $j - i32.const 1 - i32.add - local.set $j - br $for-loop|1 - end - end - local.get $registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $i - local.get $num - call $~lib/staticarray/StaticArray#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/interpreter/Interpreter#constructor@varargs (param $this i32) (param $program i32) (param $registers i32) (param $memory i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 2 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $assembly/memory/MemoryBuilder#build - local.tee $memory - i32.store offset=4 - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/interpreter/Interpreter#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/api-debugger/resetGeneric (param $program i32) (param $flatRegisters i32) (param $initialGas i64) (param $hasMetadata i32) - (local $code i32) - (local $p i32) - (local $registers i32) - (local $int i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $hasMetadata - if (result i32) - local.get $program - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/liftBytes - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/program/extractCodeAndMetadata - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $assembly/program/CodeAndMetadata#get:code - else - local.get $program - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $assembly/program/liftBytes - end - local.tee $code - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $code - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $assembly/program/deblob - local.tee $p - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=20 - local.get $registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $flatRegisters - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/api-debugger/fillRegisters - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $p - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $registers - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 2 - global.set $~argumentsLength - i32.const 0 - call $assembly/interpreter/Interpreter#constructor@varargs - local.tee $int - i32.store offset=24 - local.get $int - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/interpreter/Interpreter#get:gas - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $initialGas - call $assembly/gas/GasCounter#set@override - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $8 - i32.store offset=28 - local.get $8 - if (result i32) - local.get $8 - else - i32.const 9488 - i32.const 18336 - i32.const 38 - i32.const 19 - call $~lib/builtins/abort - unreachable - end - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/interpreter/Interpreter#get:memory - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - call $assembly/memory/Memory#free - end - local.get $int - global.set $assembly/api-debugger/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/resetGeneric@varargs (param $program i32) (param $flatRegisters i32) (param $initialGas i64) (param $hasMetadata i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 3 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - i32.const 0 - local.set $hasMetadata - end - local.get $program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $flatRegisters - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $initialGas - local.get $hasMetadata - call $assembly/api-debugger/resetGeneric - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-internal/InitialPage#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 48 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/api-internal/InitialPage#set:address - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/api-internal/InitialPage#set:length - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/memory-page/Access.None - call $assembly/api-internal/InitialPage#set:access - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api-debugger/readPages (param $pageMap i32) (result i32) - (local $1 i32) - (local $pages i32) - (local $codec i32) - (local $p i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 18608 - call $~lib/rt/__newArray - local.tee $pages - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $pageMap - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $codec - i32.store offset=8 - loop $while-continue|0 - local.get $codec - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-internal/InitialPage#constructor - local.tee $p - i32.store offset=12 - local.get $p - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $codec - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/codec/Decoder#u32 - call $assembly/api-internal/InitialPage#set:address - local.get $p - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $codec - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/codec/Decoder#u32 - call $assembly/api-internal/InitialPage#set:length - local.get $p - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $codec - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/codec/Decoder#u8 - i32.const 0 - i32.gt_u - if (result i32) - global.get $assembly/memory-page/Access.Write - else - global.get $assembly/memory-page/Access.Read - end - call $assembly/api-internal/InitialPage#set:access - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $p - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $~lib/array/Array#push - drop - br $while-continue|0 - end - end - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/api-internal/InitialChunk#constructor (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 50 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - call $assembly/api-internal/InitialChunk#set:address - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 18672 - call $~lib/rt/__newArray - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/api-internal/InitialChunk#set:data - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/array/Array#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api-debugger/readChunks (param $chunks i32) (result i32) - (local $1 i32) - (local $res i32) - (local $codec i32) - (local $c i32) - (local $len i32) - (local $data i32) - (local $i i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 51 - i32.const 18640 - call $~lib/rt/__newArray - local.tee $res - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $chunks - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $codec - i32.store offset=8 - loop $while-continue|0 - local.get $codec - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-internal/InitialChunk#constructor - local.tee $c - i32.store offset=12 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $codec - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $assembly/codec/Decoder#u32 - call $assembly/api-internal/InitialChunk#set:address - local.get $codec - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/codec/Decoder#u32 - local.set $len - global.get $~lib/memory/__stack_pointer - local.get $codec - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $len - call $assembly/codec/Decoder#bytes - local.tee $data - i32.store offset=20 - i32.const 0 - local.set $i - loop $for-loop|1 - local.get $i - local.get $len - i32.lt_u - if - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $assembly/api-internal/InitialChunk#get:data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#push - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $~lib/array/Array#push - drop - br $while-continue|0 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 14704 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 14704 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/api-internal/buildMemory (param $builder i32) (param $pages i32) (param $chunks i32) (result i32) - (local $sbrkIndex i32) - (local $i i32) - (local $initPage i32) - (local $i|6 i32) - (local $initChunk i32) - (local $data i32) - (local $i|9 i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $assembly/memory-page/RESERVED_MEMORY - local.set $sbrkIndex - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pages - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/array/Array#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $pages - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $i - call $~lib/array/Array#__get - local.tee $initPage - i32.store offset=4 - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-internal/InitialPage#get:access - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-internal/InitialPage#get:address - i32.const 0 - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-internal/InitialPage#get:length - call $~lib/typedarray/Uint8Array#constructor - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/MemoryBuilder#setData - drop - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/api-internal/InitialPage#get:access - global.get $assembly/memory-page/Access.Write - i32.eq - if - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/api-internal/InitialPage#get:address - local.get $sbrkIndex - i32.lt_u - if (result i32) - local.get $sbrkIndex - else - local.get $initPage - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/api-internal/InitialPage#get:address - end - local.set $sbrkIndex - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|6 - loop $for-loop|1 - local.get $i|6 - local.get $chunks - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/array/Array#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $chunks - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $i|6 - call $~lib/array/Array#__get - local.tee $initChunk - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $initChunk - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/api-internal/InitialChunk#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $data - i32.store offset=20 - i32.const 0 - local.set $i|9 - loop $for-loop|2 - local.get $i|9 - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $i|9 - local.get $initChunk - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-internal/InitialChunk#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - local.get $i|9 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $i|9 - i32.const 1 - i32.add - local.set $i|9 - br $for-loop|2 - end - end - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - global.get $assembly/memory-page/Access.None - local.get $initChunk - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/api-internal/InitialChunk#get:address - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/MemoryBuilder#setData - drop - local.get $i|6 - i32.const 1 - i32.add - local.set $i|6 - br $for-loop|1 - end - end - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $sbrkIndex - call $assembly/memory/MemoryBuilder#build - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $assembly/api-debugger/resetGenericWithMemory (param $program i32) (param $flatRegisters i32) (param $pageMap i32) (param $chunks i32) (param $initialGas i64) (param $hasMetadata i32) - (local $code i32) - (local $p i32) - (local $registers i32) - (local $builder i32) - (local $memory i32) - (local $int i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $hasMetadata - if (result i32) - local.get $program - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $assembly/program/liftBytes - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $assembly/program/extractCodeAndMetadata - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/program/CodeAndMetadata#get:code - else - local.get $program - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/program/liftBytes - end - local.tee $code - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $code - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/program/deblob - local.tee $p - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=20 - local.get $registers - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $flatRegisters - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $assembly/api-debugger/fillRegisters - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $pageMap - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - call $assembly/api-debugger/readPages - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $chunks - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - call $assembly/api-debugger/readChunks - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $assembly/api-internal/buildMemory - local.tee $memory - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $p - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $registers - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $memory - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $assembly/interpreter/Interpreter#constructor - local.tee $int - i32.store offset=36 - local.get $int - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $assembly/interpreter/Interpreter#get:gas - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $initialGas - call $assembly/gas/GasCounter#set@override - local.get $int - global.set $assembly/api-debugger/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/resetGenericWithMemory@varargs (param $program i32) (param $flatRegisters i32) (param $pageMap i32) (param $chunks i32) (param $initialGas i64) (param $hasMetadata i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 5 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - i32.const 0 - local.set $hasMetadata - end - local.get $program - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $flatRegisters - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $pageMap - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $chunks - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $initialGas - local.get $hasMetadata - call $assembly/api-debugger/resetGenericWithMemory - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 14704 - i32.const 8128 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/interpreter/DjumpResult#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 52 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/interpreter/DjumpStatus.OK - call $assembly/interpreter/DjumpResult#set:status - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/interpreter/DjumpResult#set:newPc - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/interpreter/dJump (param $jumpTable i32) (param $address i32) (result i32) - (local $r i32) - (local $index i32) - (local $newPc i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/interpreter/DjumpResult#constructor - local.tee $r - i32.store - local.get $address - global.get $assembly/interpreter/EXIT - i32.eq - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.HALT - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $address - i32.const 0 - i32.eq - if (result i32) - i32.const 1 - else - local.get $address - global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR - i32.rem_u - i32.const 0 - i32.ne - end - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.PANIC - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $address - global.get $assembly/interpreter/JUMP_ALIGMENT_FACTOR - i32.div_u - i32.const 1 - i32.sub - local.set $index - local.get $index - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/JumpTable#get:jumps - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.PANIC - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/JumpTable#get:jumps - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $index - call $~lib/staticarray/StaticArray#__get - local.set $newPc - local.get $newPc - global.get $assembly/interpreter/MAX_U32 - i64.ge_u - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/interpreter/DjumpStatus.PANIC - call $assembly/interpreter/DjumpResult#set:status - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $newPc - i32.wrap_i64 - call $assembly/interpreter/DjumpResult#set:newPc - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/interpreter/BranchResult#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 53 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/interpreter/BranchResult#set:isOkay - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/interpreter/BranchResult#set:newPc - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/program/BasicBlocks#isStart (param $this i32) (param $newPc i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $newPc - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i32.lt_u - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $newPc - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.START - i32.and - i32.const 0 - i32.gt_s - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/interpreter/branch (param $basicBlocks i32) (param $pc i32) (param $offset i32) (result i32) - (local $r i32) - (local $newPc i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/interpreter/BranchResult#constructor - local.tee $r - i32.store - local.get $pc - local.get $offset - i32.add - local.set $newPc - local.get $basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $newPc - call $assembly/program/BasicBlocks#isStart - if - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - call $assembly/interpreter/BranchResult#set:isOkay - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $newPc - call $assembly/interpreter/BranchResult#set:newPc - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/interpreter/Interpreter#nextStep (param $this i32) (result i32) - (local $pc i32) - (local $instruction i32) - (local $iData i32) - (local $skipBytes i32) - (local $args i32) - (local $alloc i64) - (local $gas i64) - (local $exe i32) - (local $outcome i32) - (local $10 i32) - (local $res i32) - (local $branchResult i32) - (local $branchResult|13 i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:status - global.get $assembly/interpreter/Status.HOST - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OK - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:nextPc - call $assembly/interpreter/Interpreter#set:pc - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const -1 - call $assembly/interpreter/Interpreter#set:nextPc - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const -1 - call $assembly/interpreter/Interpreter#set:exitCode - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:status - global.get $assembly/interpreter/Status.OK - i32.ne - if - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:nextPc - i32.const -1 - i32.ne - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:nextPc - call $assembly/interpreter/Interpreter#set:pc - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i32.const -1 - call $assembly/interpreter/Interpreter#set:nextPc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:pc - local.set $pc - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - call $assembly/program/Mask#isInstruction - i32.eqz - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $assembly/instructions/Instruction#get:gas - call $assembly/gas/GasCounter#sub@override - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OOG - call $assembly/interpreter/Interpreter#set:status - else - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - end - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - call $~lib/typedarray/Uint8Array#__get - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/array/Array#get:length - i32.lt_s - if (result i32) - global.get $assembly/instructions/INSTRUCTIONS - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $instruction - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION - end - local.set $iData - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $iData - call $assembly/instructions/Instruction#get:gas - call $assembly/gas/GasCounter#sub@override - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OOG - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $iData - global.get $assembly/instructions/MISSING_INSTRUCTION - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:mask - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipBytes - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/program/Program#get:code - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - local.get $pc - i32.const 1 - i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $skipBytes - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=16 - local.get $iData - global.get $assembly/instructions/SBRK - i32.eq - if (result i32) - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/Interpreter#get:useSbrkGas - else - i32.const 0 - end - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:registers - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - local.set $alloc - local.get $alloc - global.get $assembly/memory-page/PAGE_SIZE - i64.extend_i32_u - i64.add - i64.const 1 - i64.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i64.extend_i32_u - i64.shr_u - i64.const 16 - i64.mul - local.set $gas - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $gas - call $assembly/gas/GasCounter#sub@override - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.OOG - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions-exe/RUN - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $instruction - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__get - local.tee $exe - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/interpreter/Interpreter#get:registers - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $assembly/interpreter/Interpreter#get:memory - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - i32.const 3 - global.set $~argumentsLength - local.get $exe - i32.load - call_indirect (type $2) - local.tee $outcome - i32.store offset=24 - block $break|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:outcome - local.set $10 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.DynamicJump - i32.eq - br_if $case0|0 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.StaticJump - i32.eq - br_if $case1|0 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.Result - i32.eq - br_if $case2|0 - local.get $10 - global.get $assembly/instructions/outcome/Outcome.Ok - i32.eq - br_if $case3|0 - br $break|0 - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:jumpTable - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:dJump - call $assembly/interpreter/dJump - local.tee $res - i32.store offset=28 - local.get $res - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/DjumpResult#get:status - global.get $assembly/interpreter/DjumpStatus.HALT - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.HALT - call $assembly/interpreter/Interpreter#set:status - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $res - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/DjumpResult#get:status - global.get $assembly/interpreter/DjumpStatus.PANIC - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:basicBlocks - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $res - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/DjumpResult#get:newPc - i32.const 0 - call $assembly/interpreter/branch - local.tee $branchResult - i32.store offset=32 - local.get $branchResult - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/BranchResult#get:isOkay - i32.eqz - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $branchResult - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/BranchResult#get:newPc - call $assembly/interpreter/Interpreter#set:pc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $assembly/interpreter/Interpreter#get:program - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/program/Program#get:basicBlocks - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $pc - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:staticJump - call $assembly/interpreter/branch - local.tee $branchResult|13 - i32.store offset=36 - local.get $branchResult|13 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/interpreter/BranchResult#get:isOkay - i32.eqz - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $branchResult|13 - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/BranchResult#get:newPc - call $assembly/interpreter/Interpreter#set:pc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.HOST - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.HOST - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - call $assembly/interpreter/Interpreter#set:exitCode - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:pc - i32.const 1 - i32.add - local.get $skipBytes - i32.add - call $assembly/interpreter/Interpreter#set:nextPc - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.FAULT - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i64.const 1 - call $assembly/gas/GasCounter#sub@override - drop - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - global.get $assembly/memory-page/RESERVED_MEMORY - i32.lt_u - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - else - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.FAULT - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - call $assembly/interpreter/Interpreter#set:exitCode - end - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.FAULT_ACCESS - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:gas - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - i64.const 1 - call $assembly/gas/GasCounter#sub@override - drop - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:result - global.get $assembly/instructions/outcome/Result.PANIC - i32.eq - if - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - global.get $assembly/interpreter/Status.PANIC - call $assembly/interpreter/Interpreter#set:status - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $outcome - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/instructions/outcome/OutcomeData#get:exitCode - call $assembly/interpreter/Interpreter#set:exitCode - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - i32.const 18704 - i32.const 18752 - i32.const 171 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $assembly/interpreter/Interpreter#get:pc - i32.const 1 - local.get $skipBytes - i32.add - i32.add - call $assembly/interpreter/Interpreter#set:pc - i32.const 1 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - i32.const 0 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - ) - (func $assembly/api-debugger/nextStep (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 18336 - i32.const 69 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/interpreter/Interpreter#nextStep - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api-debugger/nSteps (param $steps i32) (result i32) - (local $1 i32) - (local $int i32) - (local $isOk i32) - (local $i i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 18336 - i32.const 77 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - i32.const 1 - local.set $isOk - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $steps - i32.lt_u - if - local.get $int - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/interpreter/Interpreter#nextStep - local.set $isOk - local.get $isOk - i32.eqz - if - i32.const 0 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $isOk - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - i32.const 0 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/api-debugger/getProgramCounter (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 18336 - i32.const 94 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/interpreter/Interpreter#get:pc - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api-debugger/setNextProgramCounter (param $pc i32) - (local $1 i32) - (local $int i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 18336 - i32.const 102 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $pc - call $assembly/interpreter/Interpreter#set:nextPc - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/getStatus (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - global.get $assembly/interpreter/Status.PANIC - i32.const 255 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 18336 - i32.const 110 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/interpreter/Interpreter#get:status - i32.const 255 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api-debugger/getExitArg (result i32) - (local $0 i32) - (local $int i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - i32.const -1 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 18336 - i32.const 118 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/interpreter/Interpreter#get:exitCode - local.tee $2 - if (result i32) - local.get $2 - else - i32.const -1 - end - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/api-debugger/getGasLeft (result i64) - (local $0 i32) - (local $int i32) - (local $2 i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - i64.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $0 - i32.store - local.get $0 - if (result i32) - local.get $0 - else - i32.const 9488 - i32.const 18336 - i32.const 126 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - call $assembly/interpreter/Interpreter#get:gas - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/gas/GasCounter#get@override - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/api-debugger/setGasLeft (param $gas i64) - (local $1 i32) - (local $int i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 18336 - i32.const 132 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/interpreter/Interpreter#get:gas - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $gas - call $assembly/gas/GasCounter#set@override - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/getRegister (param $reg i32) (result i64) - (local $1 i32) - (local $int i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - i64.const 0 - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 18336 - i32.const 141 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/interpreter/Interpreter#get:registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $reg - i32.const 255 - i32.and - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api-debugger/setRegister (param $reg i32) (param $value i64) - (local $2 i32) - (local $int i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $2 - i32.store - local.get $2 - if (result i32) - local.get $2 - else - i32.const 9488 - i32.const 18336 - i32.const 149 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/interpreter/Interpreter#get:registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $reg - i32.const 255 - i32.and - local.get $value - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/getRegisters (result i32) - (local $flat i32) - (local $1 i32) - (local $int i32) - (local $i i32) - (local $val i64) - (local $j i32) - (local $index i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - call $~lib/typedarray/Uint8Array#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.tee $flat - i32.store offset=4 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - local.get $flat - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store offset=8 - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 18336 - i32.const 159 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=12 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $int - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/interpreter/Interpreter#get:registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - local.get $int - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/interpreter/Interpreter#get:registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $i - call $~lib/staticarray/StaticArray#__get - local.set $val - i32.const 0 - local.set $j - loop $for-loop|1 - local.get $j - global.get $assembly/registers/REG_SIZE_BYTES - i32.lt_s - if - local.get $i - global.get $assembly/registers/REG_SIZE_BYTES - i32.mul - local.get $j - i32.add - local.set $index - local.get $flat - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $index - local.get $val - i64.const 255 - i64.and - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $val - i64.const 8 - i64.shr_u - local.set $val - local.get $j - i32.const 1 - i32.add - local.set $j - br $for-loop|1 - end - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $flat - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $assembly/api-debugger/setRegisters (param $flatRegisters i32) - (local $1 i32) - (local $int i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 18336 - i32.const 176 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $int - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $3 - call $assembly/interpreter/Interpreter#get:registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $flatRegisters - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/api-debugger/fillRegisters - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#pageDump (param $this i32) (param $index i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory/Memory#get:pages - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $index - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - call $assembly/memory/Memory#get:pages - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - local.get $index - call $"~lib/map/Map#get" - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory-page/Page#get:raw - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:data - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api-debugger/getPageDump (param $index i32) (result i32) - (local $1 i32) - (local $int i32) - (local $page i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store offset=4 - local.get $1 - if (result i32) - local.get $1 - else - i32.const 9488 - i32.const 18336 - i32.const 184 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $int - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/interpreter/Interpreter#get:memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $index - call $assembly/memory/Memory#pageDump - local.tee $page - i32.store offset=16 - local.get $page - i32.const 0 - i32.eq - if - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $page - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#bytesRead (param $this i32) (param $address i32) (param $destination i32) (result i32) - (local $nextAddress i32) - (local $destinationIndex i32) - (local $bytesLeft i32) - (local $pageData i32) - (local $relAddress i32) - (local $bytesToRead i32) - (local $source i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $address - local.set $nextAddress - i32.const 0 - local.set $destinationIndex - loop $while-continue|0 - local.get $destinationIndex - local.get $destination - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $destination - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - local.get $destinationIndex - i32.sub - local.set $bytesLeft - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - global.get $assembly/memory-page/Access.Read - local.get $nextAddress - call $assembly/memory/Memory#getPage - local.tee $pageData - i32.store offset=4 - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/PageData#get:fault - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:fault - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - end - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:relativeAddress - local.set $relAddress - local.get $relAddress - local.get $bytesLeft - i32.add - global.get $assembly/memory-page/PAGE_SIZE - i32.lt_u - if (result i32) - local.get $bytesLeft - else - global.get $assembly/memory-page/PAGE_SIZE - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:relativeAddress - i32.sub - end - local.set $bytesToRead - global.get $~lib/memory/__stack_pointer - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - call $assembly/memory/PageData#get:page - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/memory-page/Page#get:raw - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory-page/RawPage#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $relAddress - local.get $relAddress - local.get $bytesToRead - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $source - i32.store offset=20 - local.get $destination - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $source - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - local.get $destinationIndex - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $destinationIndex - local.get $bytesToRead - i32.add - local.set $destinationIndex - local.get $nextAddress - local.get $bytesToRead - i32.add - local.set $nextAddress - br $while-continue|0 - end - end - global.get $assembly/memory/NO_PAGE_FAULT - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $assembly/api-debugger/getMemory (param $address i32) (param $length i32) (result i32) - (local $2 i32) - (local $int i32) - (local $result i32) - (local $fault i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $2 - i32.store - local.get $2 - if (result i32) - local.get $2 - else - i32.const 9488 - i32.const 18336 - i32.const 197 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $length - call $~lib/typedarray/Uint8Array#constructor - local.tee $result - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $int - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/interpreter/Interpreter#get:memory - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $address - local.get $result - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=16 - local.get $6 - call $assembly/memory/Memory#bytesRead - local.tee $fault - i32.store offset=24 - local.get $fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/MaybePageFault#get:isFault - if - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - local.get $result - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/api-debugger/setMemory (param $address i32) (param $data i32) - (local $2 i32) - (local $int i32) - (local $end i32) - (local $i i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.const 0 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $2 - i32.store - local.get $2 - if (result i32) - local.get $2 - else - i32.const 9488 - i32.const 18336 - i32.const 210 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.tee $int - i32.store offset=4 - local.get $address - local.get $data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $~lib/typedarray/Uint8Array#get:length - i32.add - local.set $end - local.get $address - local.set $i - loop $for-loop|0 - local.get $i - local.get $end - i32.lt_u - if - local.get $int - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/interpreter/Interpreter#get:memory - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $i - local.get $data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $i - local.get $address - i32.sub - call $~lib/typedarray/Uint8Array#__get - call $assembly/memory/Memory#setU8 - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i64) - (local $value i64) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 8128 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api-utils/prepareProgram (param $kind i32) (param $hasMetadata i32) (param $program i32) (param $initialRegisters i32) (param $initialPageMap i32) (param $initialMemory i32) (param $args i32) (result i32) - (local $code i32) - (local $metadata i32) - (local $data i32) - (local $program|10 i32) - (local $builder i32) - (local $memory i32) - (local $registers i32) - (local $r i32) - (local $exe i32) - (local $exe|16 i32) - (local $17 i32) - global.get $~lib/memory/__stack_pointer - i32.const 48 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 48 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $program - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - call $assembly/program/liftBytes - local.tee $code - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.tee $metadata - i32.store offset=8 - local.get $hasMetadata - global.get $assembly/api-utils/HasMetadata.Yes - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $code - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - call $assembly/program/extractCodeAndMetadata - local.tee $data - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - call $assembly/program/CodeAndMetadata#get:code - local.tee $code - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - call $assembly/program/CodeAndMetadata#get:metadata - local.tee $metadata - i32.store offset=8 - end - local.get $kind - global.get $assembly/api-utils/InputKind.Generic - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $code - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - call $assembly/program/deblob - local.tee $program|10 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - local.get $initialPageMap - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=24 - local.get $17 - local.get $initialMemory - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=28 - local.get $17 - call $assembly/api-internal/buildMemory - local.tee $memory - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=36 - i32.const 0 - local.set $r - loop $for-loop|0 - local.get $r - local.get $initialRegisters - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - call $~lib/array/Array#get:length - i32.lt_s - if - local.get $registers - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - local.get $r - local.get $initialRegisters - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=24 - local.get $17 - local.get $r - call $~lib/array/Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $r - i32.const 1 - i32.add - local.set $r - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $program|10 - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - local.get $memory - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=24 - local.get $17 - local.get $registers - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=28 - local.get $17 - call $assembly/spi/StandardProgram#constructor - local.tee $exe - i32.store offset=40 - local.get $exe - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - local.get $metadata - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=24 - local.get $17 - call $assembly/spi/StandardProgram#set:metadata - local.get $exe - local.set $17 - global.get $~lib/memory/__stack_pointer - i32.const 48 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $17 - return - end - local.get $kind - global.get $assembly/api-utils/InputKind.SPI - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $code - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - local.get $args - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=28 - local.get $17 - call $assembly/program/liftBytes - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=24 - local.get $17 - call $assembly/spi/decodeSpi - local.tee $exe|16 - i32.store offset=44 - local.get $exe|16 - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - local.get $metadata - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=24 - local.get $17 - call $assembly/spi/StandardProgram#set:metadata - local.get $exe|16 - local.set $17 - global.get $~lib/memory/__stack_pointer - i32.const 48 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $17 - return - end - i32.const 18960 - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store - local.get $17 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString - local.set $17 - global.get $~lib/memory/__stack_pointer - local.get $17 - i32.store offset=24 - local.get $17 - call $~lib/string/String#concat - i32.const 19008 - i32.const 81 - i32.const 3 - call $~lib/builtins/abort - unreachable - ) - (func $"~lib/map/Map#constructor" (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.const 57 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 4 - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - i32.const 1 - i32.sub - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 4 - block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.0" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesOffset" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $"~lib/map/Map#find" (param $this i32) (param $key i32) (param $hashCode i32) (result i32) - (local $entry i32) - (local $taggedNext i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - i32.load - local.set $entry - loop $while-continue|0 - local.get $entry - if - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - local.set $taggedNext - local.get $taggedNext - i32.const 1 - i32.and - i32.eqz - if (result i32) - local.get $entry - call $"~lib/map/MapEntry#get:key" - local.get $key - i32.eq - else - i32.const 0 - end - if - local.get $entry - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $taggedNext - i32.const 1 - i32.const -1 - i32.xor - i32.and - local.set $entry - br $while-continue|0 - end - end - i32.const 0 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) - (local $newBucketsCapacity i32) - (local $newBuckets i32) - (local $newEntriesCapacity i32) - (local $newEntries i32) - (local $oldPtr i32) - (local $oldEnd i32) - (local $newPtr i32) - (local $oldEntry i32) - (local $newEntry i32) - (local $oldEntryKey i32) - (local $newBucketIndex i32) - (local $newBucketPtrBase i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $newBucketsMask - i32.const 1 - i32.add - local.set $newBucketsCapacity - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newBucketsCapacity - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newBuckets - i32.store - local.get $newBucketsCapacity - i32.const 8 - i32.mul - i32.const 3 - i32.div_s - local.set $newEntriesCapacity - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newEntriesCapacity - block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.1" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newEntries - i32.store offset=4 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entries" - local.set $oldPtr - local.get $oldPtr - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.2" - end - i32.mul - i32.add - local.set $oldEnd - local.get $newEntries - local.set $newPtr - loop $while-continue|0 - local.get $oldPtr - local.get $oldEnd - i32.ne - if - local.get $oldPtr - local.set $oldEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $newPtr - local.set $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:key" - local.set $oldEntryKey - local.get $newEntry - local.get $oldEntryKey - call $"~lib/map/MapEntry#set:key" - local.get $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:value" - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/MapEntry#set:value" - local.get $oldEntryKey - call $~lib/util/hash/HASH - local.get $newBucketsMask - i32.and - local.set $newBucketIndex - local.get $newBuckets - local.get $newBucketIndex - i32.const 4 - i32.mul - i32.add - local.set $newBucketPtrBase - local.get $newEntry - local.get $newBucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $newBucketPtrBase - local.get $newPtr - i32.store - local.get $newPtr - block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.3" - end - i32.add - local.set $newPtr - end - local.get $oldPtr - block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.4" - end - i32.add - local.set $oldPtr - br $while-continue|0 - end - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBuckets - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBucketsMask - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntries - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntriesCapacity - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#get:entriesCount" - call $"~lib/map/Map#set:entriesOffset" - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) - (local $hashCode i32) - (local $entry i32) - (local $entries i32) - (local $6 i32) - (local $bucketPtrBase i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $key - call $~lib/util/hash/HASH - local.set $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $key - local.get $hashCode - call $"~lib/map/Map#find" - local.set $entry - local.get $entry - if - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.eq - if - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.const 3 - i32.mul - i32.const 4 - i32.div_s - i32.lt_s - if (result i32) - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.const 1 - i32.shl - i32.const 1 - i32.or - end - call $"~lib/map/Map#rehash" - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.tee $entries - i32.store offset=8 - local.get $entries - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.tee $6 - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesOffset" - local.get $6 - block $"~lib/map/ENTRY_SIZE|inlined.5" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.5" - end - i32.mul - i32.add - local.set $entry - local.get $entry - local.get $key - call $"~lib/map/MapEntry#set:key" - i32.const 0 - drop - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - local.set $bucketPtrBase - local.get $entry - local.get $bucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $bucketPtrBase - local.get $entry - i32.store - end - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/gas-costs/BlockGasCost#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 54 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/gas-costs/BlockGasCost#set:pc - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/gas-costs/BlockGasCost#set:gas - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/gas-costs/computeGasCosts (param $p i32) (result i32) - (local $len i32) - (local $blocks i32) - (local $currentBlock i32) - (local $i i32) - (local $instruction i32) - (local $iData i32) - (local $skipBytes i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - local.get $p - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/program/Program#get:code - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $"~lib/map/Map#constructor" - local.tee $blocks - i32.store offset=8 - i32.const 0 - local.set $currentBlock - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $p - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/program/Program#get:mask - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - call $assembly/program/Mask#isInstruction - i32.eqz - if - i32.const 14512 - i32.const 19072 - i32.const 16 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $p - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/program/Program#get:code - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $instruction - call $~lib/array/Array#__get - end - local.set $iData - local.get $p - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/program/Program#get:basicBlocks - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - call $assembly/program/BasicBlocks#isStart - if - local.get $currentBlock - i32.const 0 - i32.ne - if - local.get $blocks - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $currentBlock - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $assembly/gas-costs/BlockGasCost#get:pc - local.get $currentBlock - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#set" - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/gas-costs/BlockGasCost#constructor - local.tee $currentBlock - i32.store offset=16 - local.get $currentBlock - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - call $assembly/gas-costs/BlockGasCost#set:pc - end - local.get $currentBlock - i32.const 0 - i32.ne - if - local.get $currentBlock - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $currentBlock - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/gas-costs/BlockGasCost#get:gas - local.get $iData - call $assembly/instructions/Instruction#get:gas - i64.add - call $assembly/gas-costs/BlockGasCost#set:gas - end - local.get $p - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/program/Program#get:mask - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipBytes - local.get $i - local.get $skipBytes - i32.add - local.set $i - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $currentBlock - i32.const 0 - i32.ne - if - local.get $blocks - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $currentBlock - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $assembly/gas-costs/BlockGasCost#get:pc - local.get $currentBlock - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#set" - drop - end - local.get $blocks - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $bufferSize i32) - (local $buffer i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 55 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:length_ - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8128 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - local.tee $2 - i32.const 8 - local.tee $3 - local.get $2 - local.get $3 - i32.gt_u - select - i32.const 2 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $bufferSize - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $length - call $~lib/array/Array#set:length_ - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.get $newLength - i32.const 2 - i32.const 0 - call $~lib/array/ensureCapacity - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $newLength - call $~lib/array/Array#set:length_ - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#values" (param $this i32) (result i32) - (local $start i32) - (local $size i32) - (local $values i32) - (local $length i32) - (local $i i32) - (local $entry i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.set $start - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.set $size - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $size - call $~lib/array/Array#constructor - local.tee $values - i32.store offset=4 - i32.const 0 - local.set $length - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $size - i32.lt_s - if - local.get $start - local.get $i - block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.6" - end - i32.mul - i32.add - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - local.tee $7 - i32.const 1 - i32.add - local.set $length - local.get $7 - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/array/Array#__set - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - call $~lib/array/Array#set:length - local.get $values - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/api-utils/getGasCosts (param $input i32) (param $kind i32) (param $withMetadata i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $program i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $kind - local.get $withMetadata - local.get $input - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - i32.const 3 - i32.const 56 - i32.const 18832 - call $~lib/rt/__newArray - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 18864 - call $~lib/rt/__newArray - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - i32.const 0 - i32.const 2 - i32.const 51 - i32.const 18896 - call $~lib/rt/__newArray - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 18928 - call $~lib/rt/__newArray - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $assembly/api-utils/prepareProgram - local.tee $program - i32.store offset=20 - local.get $program - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/spi/StandardProgram#get:program - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/gas-costs/computeGasCosts - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#values" - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/string/String#padStart (param $this i32) (param $length i32) (param $pad i32) (result i32) - (local $thisSize i32) - (local $targetSize i32) - (local $padSize i32) - (local $prependSize i32) - (local $out i32) - (local $repeatCount i32) - (local $restBase i32) - (local $restSize i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $thisSize - local.get $length - i32.const 1 - i32.shl - local.set $targetSize - local.get $pad - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $padSize - local.get $targetSize - local.get $thisSize - i32.lt_u - if (result i32) - i32.const 1 - else - local.get $padSize - i32.eqz - end - if - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $targetSize - local.get $thisSize - i32.sub - local.set $prependSize - global.get $~lib/memory/__stack_pointer - local.get $targetSize - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $prependSize - local.get $padSize - i32.gt_u - if - local.get $prependSize - i32.const 2 - i32.sub - local.get $padSize - i32.div_u - local.set $repeatCount - local.get $repeatCount - local.get $padSize - i32.mul - local.set $restBase - local.get $prependSize - local.get $restBase - i32.sub - local.set $restSize - local.get $out - local.get $pad - local.get $padSize - local.get $repeatCount - call $~lib/memory/memory.repeat - local.get $out - local.get $restBase - i32.add - local.get $pad - local.get $restSize - memory.copy - else - local.get $out - local.get $pad - local.get $prependSize - memory.copy - end - local.get $out - local.get $prependSize - i32.add - local.get $this - local.get $thisSize - memory.copy - local.get $out - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $assembly/api-utils/disassemble~anonymous|0 (param $acc i32) (param $x i32) (param $$2 i32) (param $$3 i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $acc - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $x - i32.const 16 - call $~lib/number/U8#toString - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - i32.const 2 - i32.const 15056 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $~lib/string/String#padStart - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/string/String.__concat - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#reduce<~lib/string/String> (param $this i32) (param $fn i32) (param $initialValue i32) (result i32) - (local $array i32) - (local $fn|4 i32) - (local $initialValue|5 i32) - (local $ptr i32) - (local $i i32) - (local $k i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - block $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $array - i32.store - global.get $~lib/memory/__stack_pointer - local.get $fn - local.tee $fn|4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $initialValue - local.tee $initialValue|5 - i32.store offset=8 - local.get $array - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.set $ptr - i32.const 0 - local.set $i - local.get $array - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.set $k - loop $for-loop|0 - local.get $i - local.get $k - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $initialValue|5 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - local.get $ptr - local.get $i - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.get $i - local.get $array - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 4 - global.set $~argumentsLength - local.get $fn|4 - i32.load - call_indirect (type $5) - local.tee $initialValue|5 - i32.store offset=8 - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $initialValue|5 - br $"~lib/typedarray/REDUCE<~lib/typedarray/Uint8Array,u8,~lib/string/String>|inlined.0" - end - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $assembly/api-utils/disassemble (param $input i32) (param $kind i32) (param $withMetadata i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $program i32) - (local $output i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $kind - local.get $withMetadata - local.get $input - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - i32.const 3 - i32.const 56 - i32.const 19136 - call $~lib/rt/__newArray - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 19168 - call $~lib/rt/__newArray - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - i32.const 0 - i32.const 2 - i32.const 51 - i32.const 19200 - call $~lib/rt/__newArray - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 19232 - call $~lib/rt/__newArray - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - call $assembly/api-utils/prepareProgram - local.tee $program - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 14480 - local.tee $output - i32.store offset=24 - local.get $withMetadata - global.get $assembly/api-utils/HasMetadata.Yes - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 19264 - local.tee $output - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $output - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 19312 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/string/String.__concat - local.tee $output - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $output - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $program - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=28 - local.get $9 - call $assembly/spi/StandardProgram#get:metadata - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - i32.const 19344 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - i32.const 14480 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - call $~lib/typedarray/Uint8Array#reduce<~lib/string/String> - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/string/String.__concat - local.tee $output - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $output - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 19376 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/string/String.__concat - local.tee $output - i32.store offset=24 - end - global.get $~lib/memory/__stack_pointer - local.get $output - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $program - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $assembly/spi/StandardProgram#get:program - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/api-internal/getAssembly - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/string/String.__concat - local.tee $output - i32.store offset=24 - local.get $output - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $assembly/api-internal/VmInput#constructor (param $this i32) (param $program i32) (param $memory i32) (param $registers i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 60 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/api-internal/VmInput#set:program - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/api-internal/VmInput#set:memory - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/api-internal/VmInput#set:registers - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/api-internal/VmInput#set:pc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i64.const 0 - call $assembly/api-internal/VmInput#set:gas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/string/String#substring (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $len i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $finalStart i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $finalEnd i32) - (local $14 i32) - (local $15 i32) - (local $fromPos i32) - (local $17 i32) - (local $18 i32) - (local $toPos i32) - (local $size i32) - (local $out i32) - (local $22 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $~lib/string/String#get:length - local.set $len - local.get $start - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - local.tee $6 - local.get $len - local.tee $7 - local.get $6 - local.get $7 - i32.lt_s - select - local.set $finalStart - local.get $end - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_s - select - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - local.set $finalEnd - local.get $finalStart - local.tee $14 - local.get $finalEnd - local.tee $15 - local.get $14 - local.get $15 - i32.lt_s - select - i32.const 1 - i32.shl - local.set $fromPos - local.get $finalStart - local.tee $17 - local.get $finalEnd - local.tee $18 - local.get $17 - local.get $18 - i32.gt_s - select - i32.const 1 - i32.shl - local.set $toPos - local.get $toPos - local.get $fromPos - i32.sub - local.set $size - local.get $size - i32.eqz - if - i32.const 14480 - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - end - local.get $fromPos - i32.eqz - if (result i32) - local.get $toPos - local.get $len - i32.const 1 - i32.shl - i32.eq - else - i32.const 0 - end - if - local.get $this - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - end - global.get $~lib/memory/__stack_pointer - local.get $size - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $out - local.get $this - local.get $fromPos - i32.add - local.get $size - memory.copy - local.get $out - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - ) - (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $value i64) - (local $sepLen i32) - (local $estLen i32) - (local $result i32) - (local $offset i32) - (local $value|9 i64) - (local $i i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 14480 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $lastIndex - i32.eqz - if - local.get $dataStart - i64.load - local.set $value - i32.const 0 - drop - i32.const 8 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 10 - call $~lib/util/number/utoa64 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $separator - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - local.set $sepLen - i32.const 20 - local.get $sepLen - i32.add - local.get $lastIndex - i32.mul - i32.const 20 - i32.add - local.set $estLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=4 - i32.const 0 - local.set $offset - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $lastIndex - i32.lt_s - if - local.get $dataStart - local.get $i - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $dataStart - local.get $lastIndex - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $estLen - local.get $offset - i32.gt_s - if - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.const 0 - local.get $offset - call $~lib/string/String#substring - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/staticarray/StaticArray#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 0 - drop - i32.const 1 - drop - local.get $this - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/staticarray/StaticArray#get:length - local.get $separator - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/util/string/joinIntegerArray - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/api-internal/executeProgram~anonymous|0 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 19312 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $x - i32.const 16 - call $~lib/number/U64#toString - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/string/String#concat - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $this i32) (param $fn i32) (result i32) - (local $len i32) - (local $out i32) - (local $outStart i32) - (local $i i32) - (local $result i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/staticarray/StaticArray#get:length - local.set $len - global.get $~lib/memory/__stack_pointer - local.get $len - i32.const 2 - i32.const 61 - i32.const 0 - call $~lib/rt/__newArray - local.tee $out - i32.store offset=4 - local.get $out - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.set $outStart - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.get $i - i32.const 3 - i32.shl - i32.add - i64.load - local.get $i - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - i32.const 3 - global.set $~argumentsLength - local.get $fn - i32.load - call_indirect (type $19) - local.tee $result - i32.store offset=8 - local.get $outStart - local.get $i - i32.const 2 - i32.shl - i32.add - local.get $result - i32.store - i32.const 1 - drop - local.get $out - local.get $result - i32.const 1 - call $~lib/rt/itcms/__link - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $out - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $~lib/array/Array<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) - (local $ptr i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.set $ptr - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array<~lib/string/String>#get:length_ - local.set $len - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - i32.const 1 - i32.lt_s - drop - i32.const 1 - drop - local.get $ptr - local.get $len - local.get $separator - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/util/string/joinStringArray - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api-internal/executeProgram~anonymous|1 (param $x i64) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 19312 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $x - i32.const 16 - call $~lib/number/U64#toString - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/string/String#concat - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/program/ResolvedArguments#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.const 63 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:a - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:b - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:c - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/program/ResolvedArguments#set:d - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/program/ResolvedArguments#set:decoded - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/program/resolveArguments (param $kind i32) (param $data i32) (param $lim i32) (param $registers i32) (result i32) - (local $args i32) - (local $resolved i32) - (local $6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $kind - local.get $data - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $lim - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=4 - local.get $args - i32.const 0 - i32.eq - if - i32.const 0 - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/program/ResolvedArguments#constructor - local.tee $resolved - i32.store offset=8 - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/program/ResolvedArguments#set:decoded - block $case13|0 - block $case12|0 - block $case11|0 - block $case10|0 - block $case9|0 - block $case8|0 - block $case7|0 - block $case6|0 - block $case5|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $kind - local.set $6 - local.get $6 - global.get $assembly/arguments/Arguments.Zero - i32.eq - br_if $case0|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneImm - i32.eq - br_if $case1|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoImm - i32.eq - br_if $case2|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneOff - i32.eq - br_if $case3|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegOneImm - i32.eq - br_if $case4|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegOneExtImm - i32.eq - br_if $case5|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i32.eq - br_if $case6|0 - local.get $6 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i32.eq - br_if $case7|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoReg - i32.eq - br_if $case8|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i32.eq - br_if $case9|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i32.eq - br_if $case10|0 - local.get $6 - global.get $assembly/arguments/Arguments.TwoRegTwoImm - i32.eq - br_if $case11|0 - local.get $6 - global.get $assembly/arguments/Arguments.ThreeReg - i32.eq - br_if $case12|0 - br $case13|0 - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - i64.const 32 - i64.shl - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - i64.add - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/arguments/Args#get:d - call $assembly/instructions/utils/u32SignExtend - call $assembly/program/ResolvedArguments#set:d - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:a - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:b - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $registers - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - local.get $args - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/program/ResolvedArguments#set:c - local.get $resolved - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - i32.const 16864 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $kind - i32.const 10 - call $~lib/number/I32#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $~lib/string/String#concat - i32.const 19984 - i32.const 332 - i32.const 7 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-internal/VmOutput#constructor (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 59 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - global.get $assembly/interpreter/Status.OK - call $assembly/api-internal/VmOutput#set:status - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.const 3 - i32.const 56 - i32.const 20320 - call $~lib/rt/__newArray - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/api-internal/VmOutput#set:registers - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - call $assembly/api-internal/VmOutput#set:pc - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.const 2 - i32.const 51 - i32.const 20352 - call $~lib/rt/__newArray - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/api-internal/VmOutput#set:memory - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i64.const 0 - call $assembly/api-internal/VmOutput#set:gas - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - call $assembly/api-internal/VmOutput#set:exitCode - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#slice<~lib/array/Array> (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $length i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $sourceStart i32) - (local $size i32) - (local $out i32) - (local $outStart i32) - (local $18 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $18 - global.get $~lib/memory/__stack_pointer - local.get $18 - i32.store - local.get $18 - call $~lib/staticarray/StaticArray#get:length - local.set $length - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $start - local.get $length - i32.add - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - else - local.get $start - local.tee $6 - local.get $length - local.tee $7 - local.get $6 - local.get $7 - i32.lt_s - select - end - local.set $start - local.get $end - i32.const 0 - i32.lt_s - if (result i32) - local.get $end - local.get $length - i32.add - local.tee $8 - i32.const 0 - local.tee $9 - local.get $8 - local.get $9 - i32.gt_s - select - else - local.get $end - local.tee $10 - local.get $length - local.tee $11 - local.get $10 - local.get $11 - i32.lt_s - select - end - local.set $end - local.get $end - local.get $start - i32.sub - local.tee $12 - i32.const 0 - local.tee $13 - local.get $12 - local.get $13 - i32.gt_s - select - local.set $length - local.get $this - local.get $start - i32.const 3 - i32.shl - i32.add - local.set $sourceStart - local.get $length - i32.const 3 - i32.shl - local.set $size - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $out - i32.store offset=4 - i32.const 1 - drop - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 3 - i32.const 56 - i32.const 0 - call $~lib/rt/__newArray - local.tee $out - i32.store offset=4 - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - local.get $18 - i32.store - local.get $18 - call $~lib/array/Array#get:dataStart - local.set $outStart - i32.const 0 - drop - local.get $outStart - local.get $sourceStart - local.get $size - memory.copy - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - ) - (func $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $start - local.get $end - call $~lib/staticarray/StaticArray#slice<~lib/array/Array> - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/array/Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $bufferSize i32) - (local $buffer i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 38 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $~lib/array/Array#set:length_ - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8128 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - local.tee $2 - i32.const 8 - local.tee $3 - local.get $2 - local.get $3 - i32.gt_u - select - i32.const 2 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $~lib/array/Array#set:buffer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $buffer - call $~lib/array/Array#set:dataStart - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $bufferSize - call $~lib/array/Array#set:byteLength - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $length - call $~lib/array/Array#set:length_ - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $~lib/array/Array#set:length (param $this i32) (param $newLength i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.get $newLength - i32.const 2 - i32.const 0 - call $~lib/array/ensureCapacity - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $newLength - call $~lib/array/Array#set:length_ - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#keys" (param $this i32) (result i32) - (local $start i32) - (local $size i32) - (local $keys i32) - (local $length i32) - (local $i i32) - (local $entry i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.set $start - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.set $size - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $size - call $~lib/array/Array#constructor - local.tee $keys - i32.store offset=4 - i32.const 0 - local.set $length - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $size - i32.lt_s - if - local.get $start - local.get $i - block $"~lib/map/ENTRY_SIZE|inlined.8" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.8" - end - i32.mul - i32.add - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $keys - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - local.tee $7 - i32.const 1 - i32.add - local.set $length - local.get $7 - local.get $entry - call $"~lib/map/MapEntry#get:key" - call $~lib/array/Array#__set - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $keys - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $length - call $~lib/array/Array#set:length - local.get $keys - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 8128 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - i32.const 0 - drop - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-internal/getOutputChunks (param $memory i32) (result i32) - (local $1 i32) - (local $chunks i32) - (local $pages i32) - (local $currentChunk i32) - (local $i i32) - (local $pageIdx i32) - (local $page i32) - (local $n i32) - (local $v i32) - (local $10 i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 51 - i32.const 20384 - call $~lib/rt/__newArray - local.tee $chunks - i32.store - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory/Memory#get:pages - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $"~lib/map/Map#keys" - local.tee $pages - i32.store offset=12 - i32.const 0 - local.set $currentChunk - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pages - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/array/Array#get:length - i32.lt_s - if - block $for-continue|0 - local.get $pages - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $i - call $~lib/array/Array#__get - local.set $pageIdx - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory/Memory#get:pages - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $pageIdx - call $"~lib/map/Map#get" - local.tee $page - i32.store offset=16 - local.get $page - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory-page/Page#get:raw - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $assembly/memory-page/RawPage#get:page - i32.const 0 - i32.eq - if - br $for-continue|0 - end - i32.const 0 - local.set $n - loop $for-loop|1 - local.get $n - local.get $page - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=20 - local.get $11 - call $assembly/memory-page/Page#get:raw - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory-page/RawPage#get:data - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $page - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=20 - local.get $11 - call $assembly/memory-page/Page#get:raw - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/memory-page/RawPage#get:data - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - i32.const 0 - i32.ne - if - local.get $currentChunk - i32.const 0 - i32.ne - if - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/api-internal/InitialChunk#get:data - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $v - call $~lib/array/Array#push - drop - else - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-internal/InitialChunk#constructor - local.tee $currentChunk - i32.store offset=24 - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $pageIdx - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.get $n - i32.add - call $assembly/api-internal/InitialChunk#set:address - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - global.get $~lib/memory/__stack_pointer - i32.const 1 - i32.const 0 - i32.const 27 - i32.const 0 - call $~lib/rt/__newArray - local.tee $10 - i32.store offset=28 - local.get $10 - i32.const 0 - local.get $v - call $~lib/array/Array#__set - local.get $10 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $assembly/api-internal/InitialChunk#set:data - end - else - local.get $currentChunk - i32.const 0 - i32.ne - if - local.get $chunks - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/array/Array#push - drop - i32.const 0 - local.set $currentChunk - end - end - local.get $n - i32.const 1 - i32.add - local.set $n - br $for-loop|1 - end - end - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $currentChunk - i32.const 0 - i32.ne - if - local.get $chunks - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $currentChunk - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - local.get $11 - call $~lib/array/Array#push - drop - end - local.get $chunks - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $assembly/api-internal/executeProgram (param $int i32) (param $logs i32) (result i32) - (local $isOk i32) - (local $3 i32) - (local $4 i32) - (local $instruction i32) - (local $iData i32) - (local $skipBytes i32) - (local $name i32) - (local $9 i32) - (local $10 i32) - (local $args i32) - (local $12 i32) - (local $13 i32) - (local $14 i32) - (local $15 i32) - (local $16 i32) - (local $17 i32) - (local $18 i32) - (local $19 i32) - (local $20 i32) - (local $21 i32) - (local $22 i32) - (local $23 i32) - (local $output i32) - (local $25 i32) - global.get $~lib/memory/__stack_pointer - i32.const 108 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 108 - memory.fill - i32.const 1 - local.set $isOk - block $for-break0 - loop $for-loop|0 - i32.const 1 - if - local.get $isOk - i32.eqz - if - local.get $logs - if - global.get $~lib/memory/__stack_pointer - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - call $assembly/interpreter/Interpreter#get:registers - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 16800 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray#join - local.tee $3 - i32.store offset=16 - i32.const 19504 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 1 - local.get $3 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 19504 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 14480 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - end - local.get $logs - if - global.get $~lib/memory/__stack_pointer - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=24 - local.get $25 - call $assembly/interpreter/Interpreter#get:registers - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - i32.const 19568 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=20 - local.get $25 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 16800 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/array/Array<~lib/string/String>#join - local.tee $4 - i32.store offset=28 - i32.const 19536 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 1 - local.get $4 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 19536 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 14480 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 19600 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - call $assembly/interpreter/Interpreter#get:status - i32.const 10 - call $~lib/number/I32#toString - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/string/String#concat - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 19664 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - call $assembly/interpreter/Interpreter#get:exitCode - i32.const 10 - call $~lib/number/U32#toString - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/string/String#concat - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - end - br $for-break0 - end - local.get $logs - if - i32.const 19712 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - call $assembly/interpreter/Interpreter#get:pc - i32.const 10 - call $~lib/number/U32#toString - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/string/String#concat - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 19744 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=20 - local.get $25 - call $assembly/interpreter/Interpreter#get:gas - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - call $assembly/gas/GasCounter#get@override - i32.const 10 - call $~lib/number/I64#toString - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/string/String#concat - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 19776 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - call $assembly/interpreter/Interpreter#get:status - i32.const 10 - call $~lib/number/I32#toString - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/string/String#concat - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 19408 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=24 - local.get $25 - call $assembly/interpreter/Interpreter#get:registers - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - i32.const 16800 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=20 - local.get $25 - call $~lib/staticarray/StaticArray#join - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/string/String#concat - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - end - local.get $logs - if - i32.const 19408 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=36 - local.get $25 - call $assembly/interpreter/Interpreter#get:registers - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=24 - local.get $25 - i32.const 19824 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=32 - local.get $25 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - i32.const 16800 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=20 - local.get $25 - call $~lib/array/Array<~lib/string/String>#join - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/string/String#concat - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - end - local.get $logs - if - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $assembly/interpreter/Interpreter#get:pc - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $assembly/interpreter/Interpreter#get:program - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/Program#get:code - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_u - if (result i32) - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $assembly/interpreter/Interpreter#get:program - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/Program#get:code - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/interpreter/Interpreter#get:pc - call $~lib/typedarray/Uint8Array#__get - else - i32.const 0 - end - local.set $instruction - local.get $instruction - global.get $assembly/instructions/INSTRUCTIONS - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - local.get $instruction - call $~lib/array/Array#__get - end - local.set $iData - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $assembly/interpreter/Interpreter#get:program - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/Program#get:mask - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/interpreter/Interpreter#get:pc - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipBytes - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:namePtr - local.tee $name - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $name - local.tee $9 - i32.store offset=44 - global.get $~lib/memory/__stack_pointer - local.get $instruction - i32.const 10 - call $~lib/number/U8#toString - local.tee $10 - i32.store offset=48 - i32.const 19936 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 1 - local.get $9 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 19936 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 3 - local.get $10 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 19936 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 14480 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - local.get $iData - call $assembly/instructions/Instruction#get:kind - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=20 - local.get $25 - call $assembly/interpreter/Interpreter#get:program - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - call $assembly/program/Program#get:code - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - call $assembly/interpreter/Interpreter#get:pc - i32.const 1 - i32.add - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - local.get $skipBytes - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $assembly/interpreter/Interpreter#get:registers - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/resolveArguments - local.tee $args - i32.store offset=52 - local.get $args - i32.const 0 - i32.ne - if - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/ResolvedArguments#get:a - i32.const 10 - call $~lib/number/I64#toString - local.tee $12 - i32.store offset=56 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $assembly/program/ResolvedArguments#get:decoded - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/arguments/Args#get:a - i32.const 10 - call $~lib/number/U32#toString - local.tee $13 - i32.store offset=60 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/ResolvedArguments#get:a - i32.const 16 - call $~lib/number/U64#toString - local.tee $14 - i32.store offset=64 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/ResolvedArguments#get:b - i32.const 10 - call $~lib/number/I64#toString - local.tee $15 - i32.store offset=68 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $assembly/program/ResolvedArguments#get:decoded - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/arguments/Args#get:b - i32.const 10 - call $~lib/number/U32#toString - local.tee $16 - i32.store offset=72 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/ResolvedArguments#get:b - i32.const 16 - call $~lib/number/U64#toString - local.tee $17 - i32.store offset=76 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/ResolvedArguments#get:c - i32.const 10 - call $~lib/number/I64#toString - local.tee $18 - i32.store offset=80 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $assembly/program/ResolvedArguments#get:decoded - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/arguments/Args#get:c - i32.const 10 - call $~lib/number/U32#toString - local.tee $19 - i32.store offset=84 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/ResolvedArguments#get:c - i32.const 16 - call $~lib/number/U64#toString - local.tee $20 - i32.store offset=88 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/ResolvedArguments#get:d - i32.const 10 - call $~lib/number/I64#toString - local.tee $21 - i32.store offset=92 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $assembly/program/ResolvedArguments#get:decoded - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/arguments/Args#get:d - i32.const 10 - call $~lib/number/U32#toString - local.tee $22 - i32.store offset=96 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/program/ResolvedArguments#get:d - i32.const 16 - call $~lib/number/U64#toString - local.tee $23 - i32.store offset=100 - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 1 - local.get $12 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 3 - local.get $13 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 5 - local.get $14 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 7 - local.get $15 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 9 - local.get $16 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 11 - local.get $17 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 13 - local.get $18 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 15 - local.get $19 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 17 - local.get $20 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 19 - local.get $21 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 21 - local.get $22 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 23 - local.get $23 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 20192 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - i32.const 14480 - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $~lib/console/console.log - end - end - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - call $assembly/interpreter/Interpreter#nextStep - local.set $isOk - br $for-loop|0 - end - end - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/api-internal/VmOutput#constructor - local.tee $output - i32.store offset=104 - local.get $output - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/interpreter/Interpreter#get:status - call $assembly/api-internal/VmOutput#set:status - local.get $output - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - call $assembly/interpreter/Interpreter#get:registers - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/api-internal/VmOutput#set:registers - local.get $output - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/interpreter/Interpreter#get:pc - call $assembly/api-internal/VmOutput#set:pc - local.get $output - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $assembly/interpreter/Interpreter#get:gas - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/gas/GasCounter#get@override - call $assembly/api-internal/VmOutput#set:gas - local.get $output - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=12 - local.get $25 - call $assembly/interpreter/Interpreter#get:memory - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=8 - local.get $25 - call $assembly/api-internal/getOutputChunks - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/api-internal/VmOutput#set:memory - local.get $output - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store - local.get $25 - local.get $int - local.set $25 - global.get $~lib/memory/__stack_pointer - local.get $25 - i32.store offset=4 - local.get $25 - call $assembly/interpreter/Interpreter#get:exitCode - call $assembly/api-internal/VmOutput#set:exitCode - local.get $output - local.set $25 - global.get $~lib/memory/__stack_pointer - i32.const 108 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $25 - return - ) - (func $assembly/api-internal/runVm (param $input i32) (param $logs i32) (param $useSbrkGas i32) (result i32) - (local $int i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $input - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/api-internal/VmInput#get:program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $input - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/api-internal/VmInput#get:registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $input - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/api-internal/VmInput#get:memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/interpreter/Interpreter#constructor - local.tee $int - i32.store offset=16 - local.get $int - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $useSbrkGas - call $assembly/interpreter/Interpreter#set:useSbrkGas - local.get $int - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $input - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/api-internal/VmInput#get:pc - call $assembly/interpreter/Interpreter#set:nextPc - local.get $int - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/interpreter/Interpreter#get:gas - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $input - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/api-internal/VmInput#get:gas - call $assembly/gas/GasCounter#set@override - local.get $int - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $logs - call $assembly/api-internal/executeProgram - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/api-utils/runProgram (param $program i32) (param $initialGas i64) (param $programCounter i32) (param $logs i32) (param $useSbrkGas i32) (result i32) - (local $vmInput i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $program - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/spi/StandardProgram#get:program - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $program - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/spi/StandardProgram#get:memory - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $program - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/spi/StandardProgram#get:registers - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/api-internal/VmInput#constructor - local.tee $vmInput - i32.store offset=16 - local.get $vmInput - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $initialGas - call $assembly/api-internal/VmInput#set:gas - local.get $vmInput - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $programCounter - call $assembly/api-internal/VmInput#set:pc - local.get $vmInput - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $logs - local.get $useSbrkGas - call $assembly/api-internal/runVm - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/api-utils/runProgram@varargs (param $program i32) (param $initialGas i64) (param $programCounter i32) (param $logs i32) (param $useSbrkGas i32) (result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $4of4 - block $3of4 - block $2of4 - block $1of4 - block $0of4 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of4 $1of4 $2of4 $3of4 $4of4 $outOfRange - end - unreachable - end - i64.const 0 - local.set $initialGas - end - i32.const 0 - local.set $programCounter - end - i32.const 0 - local.set $logs - end - i32.const 0 - local.set $useSbrkGas - end - local.get $program - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $initialGas - local.get $programCounter - local.get $logs - local.get $useSbrkGas - call $assembly/api-utils/runProgram - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/gas/GasCounterU64#set (param $this i32) (param $g i64) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $g - call $assembly/gas/GasCounterU64#set:gas - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/gas/GasCounterU64#sub (param $this i32) (param $g i64) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/gas/GasCounterU64#get:gas - local.get $g - i64.sub - call $assembly/gas/GasCounterU64#set:gas - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/gas/GasCounterU64#get:gas - i64.const 0 - i64.lt_s - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i64.const 0 - call $assembly/gas/GasCounterU64#set:gas - i32.const 1 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/gas/GasCounterU64#get (param $this i32) (result i64) - (local $1 i32) - (local $2 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/gas/GasCounterU64#get:gas - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#__visit" (param $this i32) (param $cookie i32) - (local $entries i32) - (local $cur i32) - (local $end i32) - (local $entry i32) - (local $val i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:buckets" - local.get $cookie - call $~lib/rt/itcms/__visit - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:entries" - local.set $entries - i32.const 1 - drop - local.get $entries - local.set $cur - local.get $cur - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.9" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.9" - end - i32.mul - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - drop - i32.const 1 - drop - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $val - i32.const 0 - drop - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - block $"~lib/map/ENTRY_SIZE|inlined.10" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.10" - end - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $entries - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28u8%29=>u8>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28u8%29=>u8>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#__visit" (param $this i32) (param $cookie i32) - (local $entries i32) - (local $cur i32) - (local $end i32) - (local $entry i32) - (local $val i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:buckets" - local.get $cookie - call $~lib/rt/itcms/__visit - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:entries" - local.set $entries - i32.const 1 - drop - local.get $entries - local.set $cur - local.get $cur - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.7" - end - i32.mul - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - drop - i32.const 1 - drop - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $val - i32.const 0 - drop - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - block $"~lib/map/ENTRY_SIZE|inlined.8" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.8" - end - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $entries - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28~lib/string/String%2Cu8%2Ci32%2C~lib/typedarray/Uint8Array%29=>~lib/string/String>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28u64%2Ci32%2C~lib/staticarray/StaticArray%29=>~lib/string/String>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/object/Object#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/rt/__newArray (param $length i32) (param $alignLog2 i32) (param $id i32) (param $data i32) (result i32) - (local $bufferSize i32) - (local $buffer i32) - (local $array i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - local.get $alignLog2 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - local.get $data - call $~lib/rt/__newBuffer - local.tee $buffer - i32.store - i32.const 16 - local.get $id - call $~lib/rt/itcms/__new - local.set $array - local.get $array - local.get $buffer - i32.store - local.get $array - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - local.get $array - local.get $buffer - i32.store offset=4 - local.get $array - local.get $bufferSize - i32.store offset=8 - local.get $array - local.get $length - i32.store offset=12 - local.get $array - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 0 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 0 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 23 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/arraybuffer/ArrayBuffer#constructor (param $this i32) (param $length i32) (result i32) - (local $buffer i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.gt_u - if - i32.const 8176 - i32.const 8224 - i32.const 52 - i32.const 43 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $buffer - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/util/number/itoa32 (param $value i32) (param $radix i32) (result i32) - (local $sign i32) - (local $out i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|8 i32) - (local $buffer|9 i32) - (local $num|10 i32) - (local $offset|11 i32) - (local $val32 i32) - (local $decimals|13 i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 14864 - i32.const 14992 - i32.const 373 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i32.eqz - if - i32.const 15056 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $value - i32.const 31 - i32.shr_u - i32.const 1 - i32.shl - local.set $sign - local.get $sign - if - i32.const 0 - local.get $value - i32.sub - local.set $value - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer - local.get $value - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 31 - local.get $value - i32.clz - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|8 - global.get $~lib/memory/__stack_pointer - local.get $decimals|8 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|9 - local.get $value - local.set $num|10 - local.get $decimals|8 - local.set $offset|11 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|9 - local.get $num|10 - i64.extend_i32_u - local.get $offset|11 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.set $val32 - local.get $val32 - i64.extend_i32_u - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|13 - global.get $~lib/memory/__stack_pointer - local.get $decimals|13 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.get $val32 - i64.extend_i32_u - local.get $decimals|13 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $sign - if - local.get $out - i32.const 45 - i32.store16 - end - local.get $out - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - ) - (func $~lib/util/number/utoa32 (param $value i32) (param $radix i32) (result i32) - (local $out i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|7 i32) - (local $buffer|8 i32) - (local $num|9 i32) - (local $offset|10 i32) - (local $decimals|11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 14864 - i32.const 14992 - i32.const 350 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i32.eqz - if - i32.const 15056 - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer - local.get $value - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 31 - local.get $value - i32.clz - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|7 - global.get $~lib/memory/__stack_pointer - local.get $decimals|7 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|8 - local.get $value - local.set $num|9 - local.get $decimals|7 - local.set $offset|10 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|8 - local.get $num|9 - i64.extend_i32_u - local.get $offset|10 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - i64.extend_i32_u - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|11 - global.get $~lib/memory/__stack_pointer - local.get $decimals|11 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $value - i64.extend_i32_u - local.get $decimals|11 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $out - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 0 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 0 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 39 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/util/number/utoa64 (param $value i64) (param $radix i32) (result i32) - (local $out i32) - (local $val32 i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|8 i32) - (local $buffer|9 i32) - (local $num|10 i64) - (local $offset|11 i32) - (local $decimals|12 i32) - (local $buffer|13 i32) - (local $num|14 i64) - (local $offset|15 i32) - (local $decimals|16 i32) - (local $17 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 14864 - i32.const 14992 - i32.const 401 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i64.const 0 - i64.ne - i32.eqz - if - i32.const 15056 - local.set $17 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $17 - return - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - call $~lib/util/number/decimalCount64High - local.set $decimals|8 - global.get $~lib/memory/__stack_pointer - local.get $decimals|8 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|9 - local.get $value - local.set $num|10 - local.get $decimals|8 - local.set $offset|11 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|9 - local.get $num|10 - local.get $offset|11 - call $~lib/util/number/utoa64_dec_lut - end - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 63 - local.get $value - i64.clz - i32.wrap_i64 - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|12 - global.get $~lib/memory/__stack_pointer - local.get $decimals|12 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|13 - local.get $value - local.set $num|14 - local.get $decimals|12 - local.set $offset|15 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|13 - local.get $num|14 - local.get $offset|15 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|16 - global.get $~lib/memory/__stack_pointer - local.get $decimals|16 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $value - local.get $decimals|16 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $out - local.set $17 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $17 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 2 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 32 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 3 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 3 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 14 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 8176 - i32.const 8288 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 2 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 35 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/util/number/itoa64 (param $value i64) (param $radix i32) (result i32) - (local $sign i32) - (local $out i32) - (local $val32 i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|9 i32) - (local $buffer|10 i32) - (local $num|11 i64) - (local $offset|12 i32) - (local $decimals|13 i32) - (local $buffer|14 i32) - (local $num|15 i64) - (local $offset|16 i32) - (local $decimals|17 i32) - (local $18 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 14864 - i32.const 14992 - i32.const 431 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i64.const 0 - i64.ne - i32.eqz - if - i32.const 15056 - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - end - local.get $value - i64.const 63 - i64.shr_u - i32.wrap_i64 - i32.const 1 - i32.shl - local.set $sign - local.get $sign - if - i64.const 0 - local.get $value - i64.sub - local.set $value - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - call $~lib/util/number/decimalCount64High - local.set $decimals|9 - global.get $~lib/memory/__stack_pointer - local.get $decimals|9 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|10 - local.get $value - local.set $num|11 - local.get $decimals|9 - local.set $offset|12 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|10 - local.get $num|11 - local.get $offset|12 - call $~lib/util/number/utoa64_dec_lut - end - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 63 - local.get $value - i64.clz - i32.wrap_i64 - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|13 - global.get $~lib/memory/__stack_pointer - local.get $decimals|13 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|14 - local.get $value - local.set $num|15 - local.get $decimals|13 - local.set $offset|16 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|14 - local.get $num|15 - local.get $offset|16 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|17 - global.get $~lib/memory/__stack_pointer - local.get $decimals|17 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.get $value - local.get $decimals|17 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $sign - if - local.get $out - i32.const 45 - i32.store16 - end - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - ) - (func $export:assembly/api-internal/getAssembly (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/api-internal/getAssembly - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/program-build/wrapAsProgram - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $export:assembly/api-debugger/resetJAM@varargs (param $0 i32) (param $1 f64) (param $2 i64) (param $3 i32) (param $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $0 - local.get $1 - local.get $2 - local.get $3 - local.get $4 - call $assembly/api-debugger/resetJAM@varargs - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api-debugger/resetGeneric@varargs (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - local.get $2 - local.get $3 - call $assembly/api-debugger/resetGeneric@varargs - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api-debugger/resetGenericWithMemory@varargs (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) (param $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $0 - local.get $1 - local.get $2 - local.get $3 - local.get $4 - local.get $5 - call $assembly/api-debugger/resetGenericWithMemory@varargs - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api-debugger/setRegisters (param $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/api-debugger/setRegisters - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api-debugger/setMemory (param $0 i32) (param $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $0 - local.get $1 - call $assembly/api-debugger/setMemory - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api-utils/getGasCosts (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - call $assembly/api-utils/getGasCosts - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $export:assembly/api-utils/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - call $assembly/api-utils/disassemble - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $export:assembly/api-utils/prepareProgram (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (result i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=16 - local.get $0 - local.get $1 - local.get $2 - local.get $3 - local.get $4 - local.get $5 - local.get $6 - call $assembly/api-utils/prepareProgram - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - ) - (func $export:assembly/api-utils/runProgram@varargs (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) (param $4 i32) (result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - local.get $3 - local.get $4 - call $assembly/api-utils/runProgram@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) -) diff --git a/build/release.d.ts b/build/release.d.ts deleted file mode 100644 index bfa811d..0000000 --- a/build/release.d.ts +++ /dev/null @@ -1,223 +0,0 @@ -/** Exported memory */ -export declare const memory: WebAssembly.Memory; -/** - * assembly/api-internal/getAssembly - * @param p `assembly/program/Program` - * @returns `~lib/string/String` - */ -export declare function getAssembly(p: __Internref30): string; -/** - * assembly/program-build/wrapAsProgram - * @param bytecode `~lib/typedarray/Uint8Array` - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function wrapAsProgram(bytecode: Uint8Array): Uint8Array; -/** - * assembly/api-debugger/resetJAM - * @param program `~lib/array/Array` - * @param pc `f64` - * @param initialGas `i64` - * @param args `~lib/array/Array` - * @param hasMetadata `bool` - */ -export declare function resetJAM(program: Array, pc: number, initialGas: bigint, args: Array, hasMetadata?: boolean): void; -/** - * assembly/api-debugger/resetGeneric - * @param program `~lib/array/Array` - * @param flatRegisters `~lib/array/Array` - * @param initialGas `i64` - * @param hasMetadata `bool` - */ -export declare function resetGeneric(program: Array, flatRegisters: Array, initialGas: bigint, hasMetadata?: boolean): void; -/** - * assembly/api-debugger/resetGenericWithMemory - * @param program `~lib/array/Array` - * @param flatRegisters `~lib/array/Array` - * @param pageMap `~lib/typedarray/Uint8Array` - * @param chunks `~lib/typedarray/Uint8Array` - * @param initialGas `i64` - * @param hasMetadata `bool` - */ -export declare function resetGenericWithMemory(program: Array, flatRegisters: Array, pageMap: Uint8Array, chunks: Uint8Array, initialGas: bigint, hasMetadata?: boolean): void; -/** - * assembly/api-debugger/nextStep - * @returns `bool` - */ -export declare function nextStep(): boolean; -/** - * assembly/api-debugger/nSteps - * @param steps `u32` - * @returns `bool` - */ -export declare function nSteps(steps: number): boolean; -/** - * assembly/api-debugger/getProgramCounter - * @returns `u32` - */ -export declare function getProgramCounter(): number; -/** - * assembly/api-debugger/setNextProgramCounter - * @param pc `u32` - */ -export declare function setNextProgramCounter(pc: number): void; -/** - * assembly/api-debugger/getStatus - * @returns `u8` - */ -export declare function getStatus(): number; -/** - * assembly/api-debugger/getExitArg - * @returns `i32` - */ -export declare function getExitArg(): number; -/** - * assembly/api-debugger/getGasLeft - * @returns `i64` - */ -export declare function getGasLeft(): bigint; -/** - * assembly/api-debugger/setGasLeft - * @param gas `i64` - */ -export declare function setGasLeft(gas: bigint): void; -/** - * assembly/api-debugger/getRegister - * @param reg `u8` - * @returns `u64` - */ -export declare function getRegister(reg: number): bigint; -/** - * assembly/api-debugger/setRegister - * @param reg `u8` - * @param value `u64` - */ -export declare function setRegister(reg: number, value: bigint): void; -/** - * assembly/api-debugger/getRegisters - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function getRegisters(): Uint8Array; -/** - * assembly/api-debugger/setRegisters - * @param flatRegisters `~lib/array/Array` - */ -export declare function setRegisters(flatRegisters: Array): void; -/** - * assembly/api-debugger/getPageDump - * @param index `u32` - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function getPageDump(index: number): Uint8Array; -/** - * assembly/api-debugger/getMemory - * @param address `u32` - * @param length `u32` - * @returns `~lib/typedarray/Uint8Array` - */ -export declare function getMemory(address: number, length: number): Uint8Array; -/** - * assembly/api-debugger/setMemory - * @param address `u32` - * @param data `~lib/typedarray/Uint8Array` - */ -export declare function setMemory(address: number, data: Uint8Array): void; -/** assembly/api-utils/InputKind */ -export declare enum InputKind { - /** @type `i32` */ - Generic, - /** @type `i32` */ - SPI, -} -/** assembly/api-utils/HasMetadata */ -export declare enum HasMetadata { - /** @type `i32` */ - Yes, - /** @type `i32` */ - No, -} -/** - * assembly/api-utils/getGasCosts - * @param input `~lib/array/Array` - * @param kind `i32` - * @param withMetadata `i32` - * @returns `~lib/array/Array` - */ -export declare function getGasCosts(input: Array, kind: number, withMetadata: number): Array<__Record54>; -/** - * assembly/api-utils/disassemble - * @param input `~lib/array/Array` - * @param kind `i32` - * @param withMetadata `i32` - * @returns `~lib/string/String` - */ -export declare function disassemble(input: Array, kind: number, withMetadata: number): string; -/** - * assembly/api-utils/prepareProgram - * @param kind `i32` - * @param hasMetadata `i32` - * @param program `~lib/array/Array` - * @param initialRegisters `~lib/array/Array` - * @param initialPageMap `~lib/array/Array` - * @param initialMemory `~lib/array/Array` - * @param args `~lib/array/Array` - * @returns `assembly/spi/StandardProgram` - */ -export declare function prepareProgram(kind: number, hasMetadata: number, program: Array, initialRegisters: Array, initialPageMap: Array<__Record48>, initialMemory: Array<__Record50>, args: Array): __Internref44; -/** - * assembly/api-utils/runProgram - * @param program `assembly/spi/StandardProgram` - * @param initialGas `i64` - * @param programCounter `u32` - * @param logs `bool` - * @param useSbrkGas `bool` - * @returns `assembly/api-internal/VmOutput` - */ -export declare function runProgram(program: __Internref44, initialGas?: bigint, programCounter?: number, logs?: boolean, useSbrkGas?: boolean): __Record59; -/** assembly/program/Program */ -declare class __Internref30 extends Number { - private __nominal30: symbol; - private __nominal0: symbol; -} -/** assembly/gas-costs/BlockGasCost */ -declare interface __Record54 { - /** @type `u32` */ - pc: number | TOmittable; - /** @type `u64` */ - gas: bigint | TOmittable; -} -/** assembly/api-internal/InitialPage */ -declare interface __Record48 { - /** @type `u32` */ - address: number | TOmittable; - /** @type `u32` */ - length: number | TOmittable; - /** @type `i32` */ - access: number | TOmittable; -} -/** assembly/api-internal/InitialChunk */ -declare interface __Record50 { - /** @type `u32` */ - address: number | TOmittable; - /** @type `~lib/array/Array` */ - data: Array; -} -/** assembly/spi/StandardProgram */ -declare class __Internref44 extends Number { - private __nominal44: symbol; - private __nominal0: symbol; -} -/** assembly/api-internal/VmOutput */ -declare interface __Record59 { - /** @type `i32` */ - status: number | TOmittable; - /** @type `~lib/array/Array` */ - registers: Array; - /** @type `u32` */ - pc: number | TOmittable; - /** @type `~lib/array/Array` */ - memory: Array<__Record50>; - /** @type `i64` */ - gas: bigint | TOmittable; - /** @type `u32` */ - exitCode: number | TOmittable; -} diff --git a/build/release.js b/build/release.js deleted file mode 100644 index 7fd5896..0000000 --- a/build/release.js +++ /dev/null @@ -1,417 +0,0 @@ -async function instantiate(module, imports = {}) { - const adaptedImports = { - env: Object.setPrototypeOf({ - abort(message, fileName, lineNumber, columnNumber) { - // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void - message = __liftString(message >>> 0); - fileName = __liftString(fileName >>> 0); - lineNumber = lineNumber >>> 0; - columnNumber = columnNumber >>> 0; - (() => { - // @external.js - throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); - })(); - }, - "console.log"(text) { - // ~lib/bindings/dom/console.log(~lib/string/String) => void - text = __liftString(text >>> 0); - console.log(text); - }, - }, Object.assign(Object.create(globalThis), imports.env || {})), - }; - const { exports } = await WebAssembly.instantiate(module, adaptedImports); - const memory = exports.memory || imports.env.memory; - const adaptedExports = Object.setPrototypeOf({ - getAssembly(p) { - // assembly/api-internal/getAssembly(assembly/program/Program) => ~lib/string/String - p = __lowerInternref(p) || __notnull(); - return __liftString(exports.getAssembly(p) >>> 0); - }, - wrapAsProgram(bytecode) { - // assembly/program-build/wrapAsProgram(~lib/typedarray/Uint8Array) => ~lib/typedarray/Uint8Array - bytecode = __lowerTypedArray(Uint8Array, 5, 0, bytecode) || __notnull(); - return __liftTypedArray(Uint8Array, exports.wrapAsProgram(bytecode) >>> 0); - }, - resetJAM(program, pc, initialGas, args, hasMetadata) { - // assembly/api-debugger/resetJAM(~lib/array/Array, f64, i64, ~lib/array/Array, bool?) => void - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - initialGas = initialGas || 0n; - args = __lowerArray(__setU8, 27, 0, args) || __notnull(); - hasMetadata = hasMetadata ? 1 : 0; - try { - exports.__setArgumentsLength(arguments.length); - exports.resetJAM(program, pc, initialGas, args, hasMetadata); - } finally { - __release(program); - } - }, - resetGeneric(program, flatRegisters, initialGas, hasMetadata) { - // assembly/api-debugger/resetGeneric(~lib/array/Array, ~lib/array/Array, i64, bool?) => void - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); - initialGas = initialGas || 0n; - hasMetadata = hasMetadata ? 1 : 0; - try { - exports.__setArgumentsLength(arguments.length); - exports.resetGeneric(program, flatRegisters, initialGas, hasMetadata); - } finally { - __release(program); - } - }, - resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata) { - // assembly/api-debugger/resetGenericWithMemory(~lib/array/Array, ~lib/array/Array, ~lib/typedarray/Uint8Array, ~lib/typedarray/Uint8Array, i64, bool?) => void - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - flatRegisters = __retain(__lowerArray(__setU8, 27, 0, flatRegisters) || __notnull()); - pageMap = __retain(__lowerTypedArray(Uint8Array, 5, 0, pageMap) || __notnull()); - chunks = __lowerTypedArray(Uint8Array, 5, 0, chunks) || __notnull(); - initialGas = initialGas || 0n; - hasMetadata = hasMetadata ? 1 : 0; - try { - exports.__setArgumentsLength(arguments.length); - exports.resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata); - } finally { - __release(program); - __release(flatRegisters); - __release(pageMap); - } - }, - nextStep() { - // assembly/api-debugger/nextStep() => bool - return exports.nextStep() != 0; - }, - nSteps(steps) { - // assembly/api-debugger/nSteps(u32) => bool - return exports.nSteps(steps) != 0; - }, - getProgramCounter() { - // assembly/api-debugger/getProgramCounter() => u32 - return exports.getProgramCounter() >>> 0; - }, - setGasLeft(gas) { - // assembly/api-debugger/setGasLeft(i64) => void - gas = gas || 0n; - exports.setGasLeft(gas); - }, - getRegister(reg) { - // assembly/api-debugger/getRegister(u8) => u64 - return BigInt.asUintN(64, exports.getRegister(reg)); - }, - setRegister(reg, value) { - // assembly/api-debugger/setRegister(u8, u64) => void - value = value || 0n; - exports.setRegister(reg, value); - }, - getRegisters() { - // assembly/api-debugger/getRegisters() => ~lib/typedarray/Uint8Array - return __liftTypedArray(Uint8Array, exports.getRegisters() >>> 0); - }, - setRegisters(flatRegisters) { - // assembly/api-debugger/setRegisters(~lib/array/Array) => void - flatRegisters = __lowerArray(__setU8, 27, 0, flatRegisters) || __notnull(); - exports.setRegisters(flatRegisters); - }, - getPageDump(index) { - // assembly/api-debugger/getPageDump(u32) => ~lib/typedarray/Uint8Array - return __liftTypedArray(Uint8Array, exports.getPageDump(index) >>> 0); - }, - getMemory(address, length) { - // assembly/api-debugger/getMemory(u32, u32) => ~lib/typedarray/Uint8Array - return __liftTypedArray(Uint8Array, exports.getMemory(address, length) >>> 0); - }, - setMemory(address, data) { - // assembly/api-debugger/setMemory(u32, ~lib/typedarray/Uint8Array) => void - data = __lowerTypedArray(Uint8Array, 5, 0, data) || __notnull(); - exports.setMemory(address, data); - }, - InputKind: (values => ( - // assembly/api-utils/InputKind - values[values.Generic = exports["InputKind.Generic"].valueOf()] = "Generic", - values[values.SPI = exports["InputKind.SPI"].valueOf()] = "SPI", - values - ))({}), - HasMetadata: (values => ( - // assembly/api-utils/HasMetadata - values[values.Yes = exports["HasMetadata.Yes"].valueOf()] = "Yes", - values[values.No = exports["HasMetadata.No"].valueOf()] = "No", - values - ))({}), - getGasCosts(input, kind, withMetadata) { - // assembly/api-utils/getGasCosts(~lib/array/Array, i32, i32) => ~lib/array/Array - input = __lowerArray(__setU8, 27, 0, input) || __notnull(); - return __liftArray(pointer => __liftRecord54(__getU32(pointer)), 2, exports.getGasCosts(input, kind, withMetadata) >>> 0); - }, - disassemble(input, kind, withMetadata) { - // assembly/api-utils/disassemble(~lib/array/Array, i32, i32) => ~lib/string/String - input = __lowerArray(__setU8, 27, 0, input) || __notnull(); - return __liftString(exports.disassemble(input, kind, withMetadata) >>> 0); - }, - prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) { - // assembly/api-utils/prepareProgram(i32, i32, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array, ~lib/array/Array) => assembly/spi/StandardProgram - program = __retain(__lowerArray(__setU8, 27, 0, program) || __notnull()); - initialRegisters = __retain(__lowerArray(__setU64, 56, 3, initialRegisters) || __notnull()); - initialPageMap = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord48(value) || __notnull()); }, 49, 2, initialPageMap) || __notnull()); - initialMemory = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerRecord50(value) || __notnull()); }, 51, 2, initialMemory) || __notnull()); - args = __lowerArray(__setU8, 27, 0, args) || __notnull(); - try { - return __liftInternref(exports.prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args) >>> 0); - } finally { - __release(program); - __release(initialRegisters); - __release(initialPageMap); - __release(initialMemory); - } - }, - runProgram(program, initialGas, programCounter, logs, useSbrkGas) { - // assembly/api-utils/runProgram(assembly/spi/StandardProgram, i64?, u32?, bool?, bool?) => assembly/api-internal/VmOutput - program = __lowerInternref(program) || __notnull(); - initialGas = initialGas || 0n; - logs = logs ? 1 : 0; - useSbrkGas = useSbrkGas ? 1 : 0; - exports.__setArgumentsLength(arguments.length); - return __liftRecord59(exports.runProgram(program, initialGas, programCounter, logs, useSbrkGas) >>> 0); - }, - }, exports); - function __liftRecord54(pointer) { - // assembly/gas-costs/BlockGasCost - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - pc: __getU32(pointer + 0), - gas: __getU64(pointer + 8), - }; - } - function __lowerRecord48(value) { - // assembly/api-internal/InitialPage - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(12, 48)); - __setU32(pointer + 0, value.address); - __setU32(pointer + 4, value.length); - __setU32(pointer + 8, value.access); - exports.__unpin(pointer); - return pointer; - } - function __lowerRecord50(value) { - // assembly/api-internal/InitialChunk - // Hint: Opt-out from lowering as a record by providing an empty constructor - if (value == null) return 0; - const pointer = exports.__pin(exports.__new(8, 50)); - __setU32(pointer + 0, value.address); - __setU32(pointer + 4, __lowerArray(__setU8, 27, 0, value.data) || __notnull()); - exports.__unpin(pointer); - return pointer; - } - function __liftRecord50(pointer) { - // assembly/api-internal/InitialChunk - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - address: __getU32(pointer + 0), - data: __liftArray(__getU8, 0, __getU32(pointer + 4)), - }; - } - function __liftRecord59(pointer) { - // assembly/api-internal/VmOutput - // Hint: Opt-out from lifting as a record by providing an empty constructor - if (!pointer) return null; - return { - status: __getI32(pointer + 0), - registers: __liftArray(pointer => BigInt.asUintN(64, __getU64(pointer)), 3, __getU32(pointer + 4)), - pc: __getU32(pointer + 8), - memory: __liftArray(pointer => __liftRecord50(__getU32(pointer)), 2, __getU32(pointer + 12)), - gas: __getI64(pointer + 16), - exitCode: __getU32(pointer + 24), - }; - } - function __liftString(pointer) { - if (!pointer) return null; - const - end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, - memoryU16 = new Uint16Array(memory.buffer); - let - start = pointer >>> 1, - string = ""; - while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); - return string + String.fromCharCode(...memoryU16.subarray(start, end)); - } - function __liftArray(liftElement, align, pointer) { - if (!pointer) return null; - const - dataStart = __getU32(pointer + 4), - length = __dataview.getUint32(pointer + 12, true), - values = new Array(length); - for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0)); - return values; - } - function __lowerArray(lowerElement, id, align, values) { - if (values == null) return 0; - const - length = values.length, - buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, - header = exports.__pin(exports.__new(16, id)) >>> 0; - __setU32(header + 0, buffer); - __dataview.setUint32(header + 4, buffer, true); - __dataview.setUint32(header + 8, length << align, true); - __dataview.setUint32(header + 12, length, true); - for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]); - exports.__unpin(buffer); - exports.__unpin(header); - return header; - } - function __liftTypedArray(constructor, pointer) { - if (!pointer) return null; - return new constructor( - memory.buffer, - __getU32(pointer + 4), - __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT - ).slice(); - } - function __lowerTypedArray(constructor, id, align, values) { - if (values == null) return 0; - const - length = values.length, - buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0, - header = exports.__new(12, id) >>> 0; - __setU32(header + 0, buffer); - __dataview.setUint32(header + 4, buffer, true); - __dataview.setUint32(header + 8, length << align, true); - new constructor(memory.buffer, buffer, length).set(values); - exports.__unpin(buffer); - return header; - } - class Internref extends Number {} - const registry = new FinalizationRegistry(__release); - function __liftInternref(pointer) { - if (!pointer) return null; - const sentinel = new Internref(__retain(pointer)); - registry.register(sentinel, pointer); - return sentinel; - } - function __lowerInternref(value) { - if (value == null) return 0; - if (value instanceof Internref) return value.valueOf(); - throw TypeError("internref expected"); - } - const refcounts = new Map(); - function __retain(pointer) { - if (pointer) { - const refcount = refcounts.get(pointer); - if (refcount) refcounts.set(pointer, refcount + 1); - else refcounts.set(exports.__pin(pointer), 1); - } - return pointer; - } - function __release(pointer) { - if (pointer) { - const refcount = refcounts.get(pointer); - if (refcount === 1) exports.__unpin(pointer), refcounts.delete(pointer); - else if (refcount) refcounts.set(pointer, refcount - 1); - else throw Error(`invalid refcount '${refcount}' for reference '${pointer}'`); - } - } - function __notnull() { - throw TypeError("value must not be null"); - } - let __dataview = new DataView(memory.buffer); - function __setU8(pointer, value) { - try { - __dataview.setUint8(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setUint8(pointer, value, true); - } - } - function __setU32(pointer, value) { - try { - __dataview.setUint32(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setUint32(pointer, value, true); - } - } - function __setU64(pointer, value) { - try { - __dataview.setBigUint64(pointer, value, true); - } catch { - __dataview = new DataView(memory.buffer); - __dataview.setBigUint64(pointer, value, true); - } - } - function __getU8(pointer) { - try { - return __dataview.getUint8(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getUint8(pointer, true); - } - } - function __getI32(pointer) { - try { - return __dataview.getInt32(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getInt32(pointer, true); - } - } - function __getU32(pointer) { - try { - return __dataview.getUint32(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getUint32(pointer, true); - } - } - function __getI64(pointer) { - try { - return __dataview.getBigInt64(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getBigInt64(pointer, true); - } - } - function __getU64(pointer) { - try { - return __dataview.getBigUint64(pointer, true); - } catch { - __dataview = new DataView(memory.buffer); - return __dataview.getBigUint64(pointer, true); - } - } - return adaptedExports; -} -export const { - memory, - getAssembly, - wrapAsProgram, - resetJAM, - resetGeneric, - resetGenericWithMemory, - nextStep, - nSteps, - getProgramCounter, - setNextProgramCounter, - getStatus, - getExitArg, - getGasLeft, - setGasLeft, - getRegister, - setRegister, - getRegisters, - setRegisters, - getPageDump, - getMemory, - setMemory, - InputKind, - HasMetadata, - getGasCosts, - disassemble, - prepareProgram, - runProgram, -} = await (async url => instantiate( - await (async () => { - const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); - if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } - else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } - })(), { - } -))(new URL("release.wasm", import.meta.url)); diff --git a/build/release.wasm b/build/release.wasm deleted file mode 100644 index 78b9842a96fab8f4348e56df8c35decf452c7135..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 97855 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 diff --git a/build/release.wasm.map b/build/release.wasm.map deleted file mode 100644 index ed93bf6..0000000 --- a/build/release.wasm.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/instructions.ts","~lib/array.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/branch.ts","assembly/instructions/jump.ts","assembly/instructions/load.ts","~lib/map.ts","~lib/util/hash.ts","~lib/util/bytes.ts","assembly/instructions/logic.ts","assembly/instructions/math.ts","assembly/instructions/misc.ts","~lib/console.ts","assembly/instructions/mov.ts","assembly/instructions/rot.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/program.ts","assembly/interpreter.ts","assembly/spi.ts","assembly/api-debugger.ts","assembly/api-utils.ts","assembly/api-internal.ts","~lib/string.ts","~lib/number.ts","assembly/program-build.ts","~lib/dataview.ts","assembly/gas.ts","assembly/gas-costs.ts","~lib/memory.ts","~lib/function.ts"],"names":[],"mappings":"6nDG4JW,EAAT,E,GA/DiD,EAAxC,CAgET,EACA,EAAO,EAAQ,EAAR,C,EACa,E,GAxDc,EAAzB,CAwDyB,EAAd,CAAP,E,cACK,EAA0B,EAA1B,CAAhB,EACO,E,GApEwC,EAAxC,CAoEP,E,SApCW,E,GAhCoC,EAAxC,CAgCP,EACI,CAAJ,EACoB,E,GAAA,CAAqB,EAA0B,IAA1B,CAArB,C,CAAP,E,cACX,EAES,E,GAAX,E,CACW,E,cACX,EAAY,E,GACZ,EAAY,EAnCmC,E,GAAqB,EAArB,CAA1B,C,SAiDjB,EAAQ,EAAR,CAAJ,EAAgC,E,MAAP,E,cAAA,EAAP,GAClB,IACY,E,EAAS,E,GA/BrB,EAEe,EAAR,G,GAAsC,EOrG/C,IACS,GAAL,CAAJ,EAAyC,G,WACS,EAAK,EAAL,CAAtB,IAArB,C,GPmGgD,EAAnB,E,EAkBvB,E,GAAX,EACA,EAU+C,EAAL,CAAc,EA7BjD,EA6Bc,CAVA,G,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,MAoLT,EAAD,CAAJ,E,EAGiB,EAFY,EAAM,EAAzB,CAAV,E,GA5NkC,EAAzB,CA8NL,CAAJ,EACE,IACE,E,GAAF,G,MF7Dc,E,GAAhB,EAC8B,EAAZ,C,CAAP,E,cACA,EAAY,EAAZ,CAAX,EAC0B,EAAR,CAAP,E,cAIP,EAAO,GAAP,CAAJ,EAEa,EAAQ,EAAd,EAIA,E,MADiB,E,SAAJ,CAAlB,EACW,CAAN,CAAL,EAEM,E,CAAN,EADY,EAAgB,EAAK,EAAL,CAAhB,CAAkC,EAAzC,EAG2B,EAAK,EAAL,CAAhB,EAAK,EAAL,E,CAAP,E,cAIA,E,GAAX,EADW,E,GAAX,EAEA,EAAU,EAAY,E,IAClB,EAAJ,EAAU,EAAY,E,IAGlB,EAAiB,EAAM,EAhIU,EAAN,CAgIA,EAhID,CAAgC,EAAjC,CAA3B,GADK,GAiIH,CAAJ,EAvHE,EAwHsB,EAzHxB,GA4HO,EAAD,CAAJ,EACoB,EAAM,EAxJO,EAAN,CAA3B,GADK,G,EA0J6B,EAAP,C,CAAT,EAhJlB,EAgJkB,EAjJpB,GAoJS,EAAD,CAAJ,EAAY,I,KAAqB,EAAP,C,aArGZ,E,CAAP,E,cACK,E,GAAhB,EAC8B,EAAZ,C,CAAP,E,cAEU,EA5G+B,EAA3B,CAA6C,E,GAAe,EAAf,CAA/D,CA4GP,E,GACA,EAGgB,EAAZ,CAAJ,EACc,EAAM,EAAlB,EACA,EAA2B,EAAY,EAAZ,CAA8B,EAAY,EAAZ,CAA9B,CAAZ,E,GACE,EAnHiC,EAA3B,CAA6C,E,GAAe,EAAf,CAA/D,CAmHL,E,GACA,GAKE,EAAY,EAAZ,CAAJ,EACyB,EAhIqB,EAA3B,CAAZ,GAgIL,E,GACA,EAC6B,EAAX,C,CAAP,E,cACC,EAAM,EAAlB,EACA,EAC2B,EAAW,EAAX,CAA6B,EAAY,EAAZ,CAA7B,CAAZ,E,IAIjB,EAAe,EAAY,EAAZ,C,GAIJ,EAAY,EAAZ,CAAX,EAC0B,EAAR,CAAP,E,cAC2D,EAApD,EAA2B,EAA3B,CAA4C,EAA5C,EAAP,E,cAGE,EAA2B,EAA3B,CAA4C,EAAzD,GAII,EAAO,GAAP,CAAJ,EAEa,EAAQ,EAAd,EAIA,E,MADiB,E,SAAJ,CAAlB,EACW,CAAN,CAAL,EAEM,E,CAAN,EADY,EAAgB,EAAK,EAAL,CAAhB,CAAkC,EAAzC,EAG2B,EAAK,EAAL,CAAhB,EAAK,EAAL,E,CAAP,E,cAGQ,EAAM,EAzFY,EAAN,CAyFF,EAzFC,CAAgC,EAAjC,CAA3B,CADK,GA0FP,EACA,E,KACA,EAAa,E,GACT,EAAJ,EAAU,EAAY,E,IACd,EAAM,EApFuB,EAAN,CAoFb,EApFY,CAAgC,EAAjC,CAA3B,CAoFoB,EArFtB,GAwFA,I,GAAe,EAAK,EAAL,C,IACT,EAAM,EA3GuB,EAAN,CAA3B,GATA,EADK,GAqH4B,EAAK,EAAL,CAAnB,CA5GhB,G,MAoOgC,E,EAAd,EAAP,E,cACD,E,EAAA,CAAoC,EAArC,CAAiD,EAAlD,CAAR,EAGmB,EA3MZ,IA2MP,EAEA,EAC6B,EAA0B,EAA1B,CAAT,GAAP,E,cAIiB,EAAxB,EAAQ,EAAR,IAAJ,EAEa,E,GAAX,E,EADA,IAQc,EAA0B,GAA1B,CAAT,GADS,E,iBApBR,CAGH,E,CAsBU,EAAN,CAAX,EACW,EAAP,CAAJ,E,EAOA,EAAiC,EAAW,EAAX,CAFlB,EAAO,EAAP,CAAf,EAEyB,EAAX,E,GACd,E,KACA,E,KAGyB,EAAQ,EAAR,CAAyB,EAA3C,CAAP,E,KAEQ,EAAM,EArOd,IAuOY,EAAM,EAAlB,E,MA8CkB,EAAlB,EACkB,EACd,GAAyC,EAAc,EAAd,CAAZ,EAAyC,EAAzC,E,GAAjC,EAA6E,EAClE,IACE,E,GACL,IAAM,EA1Rd,G,EA2RwB,EAAK,EAAL,C,EACV,EAjUqB,EAAN,CAiUrB,IAjUN,CAiUgB,EAlUlB,GAmUqB,EAAd,E,EAAiB,EAAK,EAAL,C,EACN,EAhTmB,EAAN,CAgTT,EAhTQ,CAAgC,EAAjC,CAgTjB,IAhTV,CAgTwB,EAjT1B,GAgTwC,E,GAAF,E,IAFE,E,GAAF,E,IAY1B,IANG,I,EAMa,CAAsB,EAAtB,C,EAErB,IAAP,E,MEnTA,E,MAAQ,E,OAEI,EAAR,EACa,EAAb,EACA,EACO,EAAP,EACO,EAAP,EAGiB,EAAL,CAAZ,EACM,E,GAlGuC,EAAxC,CAkGL,EACA,EAAO,EAAO,EAAP,C,EACE,EAAP,EACiB,EAAb,E,KA3FwB,EAAzB,CA2FC,CAAJ,EACE,E,EAvFqC,EAArB,CAuFJ,EAvFG,C,GAwFF,EAAb,EACgB,EAAyB,EAAzB,CAAhB,EACO,EAAP,EAEI,E,GA3GqC,EAAxC,CA2GH,E,IAEW,EAAb,EACA,EAEW,EADL,E,GA/GuC,EAAxC,CAgHD,CAAJ,EAtCM,EAAV,EACA,EAAO,EAAM,IAAN,C,EACe,EAAZ,GAAR,EACA,EAAO,E,CAAP,E,IAqCU,E,GAlHqC,EAAxC,CAkHH,EACA,EAAO,EAAO,EAAP,C,EACY,EAAb,E,KA1GsB,EAAzB,CA0GG,CAAJ,EACE,E,EAtGmC,EAArB,CAsGF,EAtGC,C,GAuGG,EAAyB,EAAzB,CAAhB,GAEI,E,GAxHmC,EAAxC,CAwHD,E,IAES,EAAX,EACY,EAAZ,EACU,EAAV,EACQ,EAAR,EACO,E,GA9HoC,EAAxC,CA8HH,EACQ,EAAR,GAEK,EAAP,EAGM,EAAN,EACW,EAAP,CAAJ,EACS,E,KAtIoC,EAAxC,CAsIH,EACoC,EAAL,C,EA7HH,EAAzB,CA6He,CAAP,E,cACN,EAckB,IAAzB,CAAJ,EACE,EAAoB,E,GACpB,EAAW,E,IAEX,EAAS,E,GAtI8B,EAAd,CAAlB,G,CAsIP,EAIO,EAAyB,EAAzB,CFiVL,EAAM,IAAN,C,EACC,EAAD,CAAJ,EAAW,GACD,EAAqB,EA9BK,EAAxB,CAAZ,EAEgB,EAAM,EAAN,C,EAAd,K,GACE,E,GAAe,EAAf,EAFJ,E,cAIO,EAXQ,E,GAAe,EAAf,C,GACG,EAAlB,IErUa,EAAP,EAEF,EAAwB,E,GACxB,EAAe,E,GACP,EAAR,G,QF0FA,EAAO,GAAP,CAAJ,EAEa,EAAQ,EAAd,CAAL,GAbK,EAAO,MAAP,GACH,EAAQ,EAAM,EAAsB,EAAX,CAAX,CAAN,CAAR,CAA8C,EAA9C,CAcF,G,EACK,EAdH,EAc6B,CAA1B,CAAL,EACiC,EAAL,CAAhB,CAAkC,EAAzC,CAAL,EACA,EAAM,E,CAAN,GAEgC,EAAK,EAAL,CAAhB,EAAK,EAAL,E,CAAP,E,cAGO,EAAM,EA/LW,EAAN,CAA3B,CADK,GAgMwB,EAAM,EAAN,CAAnB,CAAZ,EAEA,EAYiB,EAAmB,EAAT,CAAJ,EA1Lc,EAAN,CAAD,CAAgC,EAAjC,CAA3B,CADK,IAiLO,E,GAAc,EAAO,EAAK,EAAL,CAAP,CAAd,CAAZ,EACA,EAIgB,EADE,EAAX,CAAL,EAvM+B,EAAN,CAA3B,CADK,GAyMH,E,CACW,E,cACI,EAAmB,EAAT,CAAJ,EAvLY,EAAN,CAAD,CAAgC,EAAjC,CAA3B,CADK,I,UAySH,EAAO,MAAP,CAAJ,EAA0C,G,YAkClB,EAzCjB,EAAQ,EAAR,GACH,GACE,E,EAAA,CAAmC,EAApC,CAAgD,EAAjD,EAsCJ,EACY,EAAZ,EACI,CAAJ,EAxDkB,EAAlB,EALI,EAAQ,GAAR,CAAJ,EAzHO,EAAO,MAAP,GACH,EAAQ,EAAM,EAAsB,EAAX,CAAX,CAAN,CAAR,CAA8C,EAA9C,EACA,I,GA6HI,EAAiG,EAlQlG,IAiQP,EACuD,EAAtB,CAA4B,EAA7B,CAAN,CAAlB,CACkB,CAAO,IAAP,CAAiB,IAAlB,CAA+B,EAAtC,CAAlB,E,KACkB,CACd,EAA2B,EAA3B,CAAJ,EACkB,EAAZ,EAA2B,EAA3B,CAAJ,EAAkC,GAG1B,EAAM,EAAsB,EAAtB,CADC,EACyB,CAAmB,EAAnB,C,EAkDF,EAAM,EAApC,EAAR,E,CACW,E,eAEoC,EAA9B,E,GAAe,EAAf,CAAD,CAAP,E,cACC,EAAM,EAAlB,EA9IgB,E,GAAhB,EACqB,EAAO,EAAP,CAAyB,EAA1B,CAAT,E,cAGM,EAAY,EAAZ,CAA0B,EAA3B,CAAhB,EACiB,EAAb,CAAJ,EACE,EAAe,EAAQ,EAAY,EAAZ,CAAR,C,GAEe,EAA2B,EAA3B,CAA4C,EAA9D,CAAZ,EACgB,EAAY,EAAZ,CAA8B,EAA/B,C,GACH,EAAM,EAAlB,GAIA,EAAe,EAAY,EAAZ,C,GACN,EAtRyC,EAA3B,CAA6C,E,GAAe,EAAf,CAA/D,K,GAsRqB,E,KAkIrB,E,MEpPH,EAAQ,MAAR,CAAJ,EAA4C,G,YACxC,EAAS,EAAT,CAAJ,E,EA2IoB,GAApB,EACA,EACE,EAAU,E,CAAV,EACI,GAAJ,E,EAEsB,C,GAAA,CAA0B,G,CAAlC,CAAyC,GAAzC,CAAZ,EAEA,GAEK,EAAS,EAAT,C,GAEG,EAA4B,EAAQ,EAAR,CAAoB,GAA1B,CAAd,GAAR,CAAZ,IFgKK,EAAD,CAAJ,EAAW,GAC4B,EEtTgB,EAAlB,GFsT9B,EEtTP,EACW,E,GACX,EAAa,E,GACF,EA/HE,E,GAAX,EA+HF,EA9HuB,EA8HD,EA9HC,C,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,GA4Hd,EAAS,E,GAzJgC,EAAd,CAAlB,G,CAyJT,EACU,EAAyB,EAAzB,CAAV,EAEiB,EAAG,EAApB,GACO,E,GC9MY,EAAG,EAAG,EAAG,EAAnB,E,KDqOJ,EAAD,CAAJ,EAAe,EACG,E,CAAP,E,cAEQ,EADY,EAAW,EAA9B,CAAZ,E,GAhMkC,EAAzB,CAiML,CAAJ,EACkC,EAAY,EAA/B,CAAb,E,GAlMgC,EAAzB,CAmMP,EACwB,EAAL,CAAf,CAAJ,EAKI,EAGA,EANE,EAAJ,CAME,GAEqC,EAAS,EAAT,CAA9B,EAAe,EAAf,EAAJ,EAEL,O,KFoQC,EAAD,CAAJ,EAAW,GAC4B,EAAM,EAAtC,EAA+C,EAA/C,C,EcvjBU,E,KACC,E,KACP,E,KACc,E,KAKb,E,GACZ,EAAS,E,GACT,EAAQ,E,GACR,EAAkB,E,GACX,E,4CMaG,E,OACV,E,KAAY,E,KACZ,E,KAAW,E,UACJ,E,GAkBA,E,MdqIP,EAAO,EAAO,IAAP,C,EAGG,EAAM,IAAN,CAAR,EADQ,EAAM,IAAN,CAER,EASW,EADX,EAAU,E,CAAV,EAC+B,EAAV,CAAV,CAPF,EAAI,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAFL,EAAI,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAG2C,EAAX,CAAX,CAAnC,G,IAGE,EAAO,GAAP,CAAJ,EAMa,EAFX,EAAU,E,CAAV,EAE+B,EAAV,CAAV,CAJF,EAAM,GAAN,CAGqC,EAAb,CAAV,KAAV,GACb,GALS,EAAM,GAAN,CAET,G,EAMS,EAAP,CAAJ,EAGa,EAFX,EAAU,EAEW,CAAU,EAAV,CAAV,CADsB,EAAc,EAAd,CAAV,KAAV,GACb,IAIW,EAFX,EAAU,EAEW,CAAU,EAAV,CAAV,CADe,EAAd,GACZ,I,QAgHS,CAAX,EACK,EAAS,EAAQ,EAAR,CAAT,CAAL,EASE,EAGa,EAFX,E,GAAA,EAE+B,EAAV,CAAV,CAA+C,EADlD,EAAM,EAAN,CAAR,EACoE,EAAJ,C,CAAZ,CAAyB,EAAzB,CAAP,KAAV,GAAnC,GACM,E,OAZY,EAAJ,CAAa,E,CAAjB,CAAZ,EACW,EAAO,EAAP,CAAX,EACA,EAEa,EADX,E,GAAA,EAC+B,EAAV,CAAV,CAA+C,EAAM,E,CAAZ,CAAqB,EAArB,CAAP,KAAV,GAAnC,GACA,EAAQ,E,CAAR,E,sDAuCC,EAAD,CAAJ,E,OAAmB,I,EAAP,G,IAGO,EAAD,C,EADN,EAAU,EAAV,CAAiB,EAAlB,CAAX,EACA,CAAU,EApPE,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,GAVX,EAyP8C,EAAZ,CAAiB,EAAlB,CAAwB,EAAjD,E,KACU,EAAyB,EAAzB,CAA+B,EAAO,EA5FjD,EAuGH,EAAJ,EAAqB,EAAwB,EAAnC,I,gBA7KV,EAAO,EAAO,KAAP,C,EAiBM,EADX,EAAU,E,CAAV,EAC+B,EAAV,CAAV,CAfK,EADR,EAAM,KAAN,CAAR,EAC0B,KAAJ,C,CAAd,CAAR,EAIY,IAAJ,CAAR,EAIa,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAFL,EAAI,GAAJ,CAG2C,EAAb,CAAV,KAAf,GAG2C,EAAX,CAAX,CAAnC,GAMW,EADX,EAAU,E,CAAV,EAC+B,EAAV,CAAV,CAlBH,EAAI,IAAJ,CAAR,EAGa,GAAJ,CAWuC,EAAb,CAAV,KAAf,GAVD,EAAI,GAAJ,CAWuC,EAAb,CAAV,KAAf,GAG+C,EAAX,CAAX,CAAnC,G,IAGa,E,EAAQ,CAAU,EAAjC,E,MAyiBW,EAAX,EAeQ,EAAQ,EAAR,CADC,EAEQ,EAAQ,E,EAAA,CAAnB,GACO,EAAP,EAUA,EAAc,MAAd,CADC,E,EAES,CAvrBZ,EAAQ,IAAR,CAAJ,EACM,EAAQ,GAAR,CAAJ,EACiB,EAAS,EAAb,CAAJ,IAEQ,EAAS,IAAb,CAAJ,GAA8B,EAAS,GAAb,CAA1B,GAGL,EAAQ,KAAR,CAAJ,EACiB,EAAS,IAAb,CAAJ,IAEQ,EAAS,MAAb,CAAJ,GAAmC,EAAS,KAAb,CAA/B,G,EA+qBS,EAAM,EAAO,EA3hB1B,GA+hBa,EAAM,EAFV,EAzqBJ,SAAR,CAAJ,EACM,EAAQ,OAAR,CAAJ,EACkB,EAAS,OAAb,CAAL,GAAsC,EAAS,MAAb,CAAlC,EAES,EAAS,QAAb,CAAL,GAAyC,EAAS,QAAb,CAArC,GAGL,EAAQ,UAAR,CAAJ,EACkB,EAAS,SAAb,CAAL,IAES,EAAS,WAAb,CAAL,GAA8C,EAAS,UAAb,CAA1C,GAgqBP,EA1gBG,GA8gBO,E,KJvfV,EAAJ,EAC+B,EAAM,EAAzB,CAAV,E,GAxOgC,EAAzB,CAyOU,EAAb,CAAJ,EACkB,I,YAElB,IACW,EA1MA,E,GAAX,EACA,EAAqB,EAA0B,EAA1B,C,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,IAwMP,E,KAMF,EAAD,CAAJ,EAAU,EACmB,EAAM,EAAzB,CAAV,E,GAtPkC,EAAzB,CAuPQ,EAAb,CAAJ,EACkB,I,YAEd,EAAS,EAAT,CAAJ,EAIE,KAEA,IACW,EA9NA,E,GAAX,EA8NA,EA7NqB,EA6NC,EA7ND,C,GACrB,EAAY,E,GACZ,EAAY,EA3CmC,E,GAAqB,EAArB,CAA1B,C,GA4CrB,EAAY,E,OAkOV,EAAQ,EAAR,CAAJ,EAEE,EAAO,E,aAIT,EAAO,E,WACa,C,GAAA,CAA0B,G,CAAlC,CAAyC,GAAzC,CAAZ,E,yDkD5VE,E,KAAW,E,yEAQX,E,KAAW,E,UAAW,EAAX,C,KACP,E,QAAW,EAAX,CAAJ,E,EACE,E,KAAW,E,UACJ,EAAP,G,OAEK,G,8DATA,E,iExB0MmB,E,QAA1B,E,EACgC,E,QAAhC,EAEE,E,EACuB,E,GAAb,E,KAAkC,EAA5B,CAAN,CAAV,EACA,EAAa,EAAN,G,EACO,E,GACa,EAAnB,CAAF,CAAJ,EAQgC,EAGb,GAAR,GAGX,EAAO,E,CAAP,E,IAGI,EAAR,E,qQLuIY,EAAyB,EAA0B,EAA7C,C,GAAN,CAAV,EACA,EAAO,EAAM,EAAN,C,EACiB,EAAZ,GAAV,EACA,EAAiB,EAAR,GACT,EAAO,E,CAAP,E,kHRuHQ,E,QAAV,E,EACwB,E,GAAd,E,KAA8B,EAAvB,CAAP,CAAV,EACA,EAAO,EAAM,EAAN,C,EACiB,EAAZ,GAAV,EACA,EAAiB,EAAR,GACT,EAAO,E,CAAP,E,gCwCreI,E,QAAR,E,oGxCwe0B,E,QAA1B,E,mCbrdF,GAAsB,G,GACtB,GAAa,G,GACN,G,EAFP,GAAsB,G,GACtB,GAAa,G,GACN,G,EAFP,GAAsB,G,GACtB,GAAa,G,GACN,G,yKCnBE,E,YAMA,E,YAIA,E,YACA,E,0DAxBG,E,OACV,E,KAAM,E,KACN,E,KAAM,E,KACN,E,KAAM,E,KACN,E,KAAM,E,UACC,E,4COoIA,E,qEA2DyB,E,KAi2CxB,E,KAAA,EAAV,E,EAKmC,EAAoB,EAA7C,E,OACkB,E,GACf,E,KADb,EACA,GACO,EAAwB,EAAK,EAApC,E,EACqC,E,GAAxB,E,KA12C2B,EAk2CxB,EAAR,GAAsB,EAAN,G,SAAJ,EAA0B,EAAO,E,KAAX,EAA1C,EAQqC,CAArC,GACW,EARH,EAAQ,EAAR,GAAsB,EAAN,G,SAAJ,EAA0B,EAAO,E,KAAX,E,EACzB,E,KAAT,CAOkC,EAAN,CAApC,G,OACO,E,4CAl6CkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cAC7C,E,GAAiB,E,KAAjB,CAAT,G,sDPjBI,E,OAAe,EAAqB,EAAM,EAAd,EAAN,IAAtB,E,OACgB,E,OAAA,CAAH,SSohCjB,CTphCG,EAAZ,EACU,EAAV,E,EACyB,EAAJ,G,IACR,E,GAAX,E,EAAgB,EAAT,EAAiB,EAAI,EAAJ,CAAjB,C,CAAP,EAD4B,E,GAAA,E,IAKL,GAAO,EADpB,I,EAAU,K,EAAK,EAAM,EAAN,CAAL,EAAgB,GAAhB,EAAuB,GAC9B,CAAf,E,EACuB,EAAI,EAAJ,C,EACrB,EAAO,EAAW,EAAI,EAAJ,CAAX,C,CAAP,EAD4B,E,GAAA,E,WAGvB,E,4CA9FsB,E,KAAM,EAAG,EAAnB,EAAyB,EAAG,EAAG,EAAzC,E,wGAkEC,E,YACA,E,iBAQV,E,KAHY,EAAO,EAAP,C,KAIZ,E,KAHY,E,IAAQ,EAAR,C,UAIL,E,gEA3FW,E,OAAK,EAAL,EAAR,E,OACqB,E,QAAA,CAAH,SSonCnB,CTpnCK,EAA0B,EAA1B,CAAd,E,EACwB,E,KAAM,EAAG,EAAnB,E,EACW,EAAV,G,EAAgB,EAAO,EAAvB,EACiB,EAAG,EAA5B,E,mDAae,E,KAAM,EAAb,E,qDAOY,E,KAAK,EAAL,EAAR,E,WAAA,G,EAAgC,EAAV,G,EAAgB,EAAG,EAAnB,EAAyB,EAAG,EAA5D,E,sEO6Ia,E,GAAc,M,uEP3CtB,E,KAAK,EAAT,E,EACC,E,KAAK,EAAT,EAAgB,EAAhB,C,GACI,E,KAAK,EAAT,EAAgB,EAAhB,C,GACI,E,KAAK,EAAT,EAAgB,EAAhB,C,uDAjGa,E,KAAK,EAAL,EAAR,E,WAGO,G,EAFG,E,SAAc,EAAd,E,WAAV,E,EACU,E,SAAc,EAAd,E,WAAV,EACgB,EAAnB,E,sDAIW,E,OAAK,EAAL,EAAR,E,OACqB,E,QAAA,CAAH,SSilCrB,CTjlCO,EAA0B,EAA1B,CAAd,E,EACuB,E,KAAM,EAAG,EAAnB,EAAb,E,EACuB,E,KAAM,EAAO,EAAvB,EAAb,E,EACiB,E,KAAA,GAAO,EAAM,EAAM,EAA7B,E,mDAYW,E,OAAK,EAAL,EAAR,E,OACO,E,KAAA,G,EAAO,K,EAAA,GAAO,EAAG,EAA3B,E,qDAIW,E,OAAK,EAAL,EAAR,E,OACO,E,KAAA,G,EAAO,K,EAAA,G,EAAiB,EAAV,G,EAAgB,EAAG,EAAnB,EAAyB,EAAjD,E,6DASW,E,OAAK,EAAL,EAAR,E,SACY,E,SAAc,EAAd,E,WAA4B,EAAM,EAAN,CAAU,EAApB,EAAM,EAAN,EAAzB,I,YACE,G,EAAO,K,EAAA,G,cAAiB,E,QAAlC,E,6DAIW,E,OAAK,EAAL,EAAR,E,OACQ,E,OAAK,EAAL,EAAR,E,cACO,G,EAAO,K,EAAA,G,EAAO,K,EAAA,GAAO,EAA/B,E,sDYhHgB,E,GACrB,E,KADJ,EAC8B,EAAhB,CAAV,CAAJ,EACM,EAAU,MAAkB,EAAlB,CAAV,CAAJ,EAAgE,I,cAChC,E,QAAhC,E,EAGsB,E,KAAJ,CAA0B,EAA1B,CAAlB,EACI,EAAJ,E,MAAmC,EAAe,EAAf,C,WAAJ,C,EAAsC,E,KAA1C,CAAd,G,EACS,Eb4PiB,EAA5B,CAAb,E,GAE6B,EAAhB,CAAsB,EAAvB,C,EAAR,CAAJ,EACE,EAAgB,E,GACT,E,EAAP,GAIiB,EAAM,E,GAAZ,EAAb,EACoB,EAAY,EAAM,E,UAAV,CAA5B,KarQE,EAMe,EAAX,CAAJ,EACe,EAAO,EAApB,GACa,EAAO,EAApB,GACO,EAAO,EAA4B,EAA1C,GAES,EAAO,EAAlB,I,sDA6FuB,E,GAAnB,E,KAAA,CAAJ,EACM,EAAQ,EAAR,CAAJ,EAAoC,G,aACrB,EAAyB,EAAQ,EAAR,GAAW,EApH6B,EAoHhF,E,EACA,E,KAAe,E,MAER,E,QAAkB,EAAgB,EAAhB,CAAlB,CAAiD,EAA1D,G,gvIGtHiB,E,YACC,E,YACP,E,oKCCP,EAAc,MAAd,CAAJ,EAAyE,I,cACrB,EAAqB,EAA5D,E,OAIb,E,KAAc,E,oBACd,E,KAAiB,E,KACjB,E,KAAkB,E,+TIoDK,E,GAAnB,E,EAjBgD,EAA7C,C,GAAwE,EAAxE,CAiBH,CAAJ,EAAyD,G,aACrC,EAA2B,EAAgB,EAAhB,CAA3B,CAAR,G,mDAcW,E,GAAnB,E,EAhCgD,EAA7C,C,GAAwE,EAAxE,CAgCH,CAAJ,EAAyD,G,eACzD,E,KAAY,EAIwC,EAAhB,CAA3B,CAJU,EAInB,G,6FH3EiB,E,YACD,E,YACL,E,YACI,E,YACD,E,kECrBhB,E,KAAS,E,KAAA,G,IAAuB,E,KAAS,E,KC6EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7EM,G,EC6EgB,CAAlD,EAAK,EAAL,ED7EyB,EAAZ,CAApB,ED8CO,E,6DCxCP,E,KAAS,E,KAAA,G,IAA2B,E,KAAS,E,KCuEV,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvEU,G,ECuEY,CAAlD,EAAK,EAAL,E,EDvEyB,CAAZ,CAAY,CAAhC,EDwCO,E,6DClCP,E,KAAS,E,KAAA,G,IAAoB,E,KAAS,E,KCiEH,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDjEG,G,ECiEmB,CAAlD,EAAK,EAAL,EDjEsB,EAAT,CAApB,EDkCO,E,6DC5BP,E,KAAS,E,KAAA,G,IAAwB,E,KAAS,E,KC2DP,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED3DO,G,EC2De,CAAlD,EAAK,EAAL,E,ED3DsB,CAAT,CAAS,CAA7B,ED4BO,E,6DCtBP,E,KAAS,E,KAAA,G,IAAoB,E,KAAS,E,KCqDH,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDrDG,G,ECqDmB,CAAlD,EAAK,EAAL,EDrDsB,EAAT,CAApB,EDsBO,E,6DChBP,E,KAAS,E,KAAA,G,IAAwB,E,KAAS,E,KC+CP,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED/CO,G,EC+Ce,CAAlD,EAAK,EAAL,E,ED/CsB,CAAT,CAAS,CAA7B,EDgBO,E,6DCVP,E,KAAS,E,KAAA,G,IAA2B,E,KAAS,E,KCyCV,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDzCU,G,ECyCY,CAAlD,EAAK,EAAL,E,EDzC0B,CC0BlB,CAAR,CD1BP,EDUO,E,6DCJP,E,KAAS,E,KAAA,G,IAA6B,E,KAAS,E,KCmCZ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDnCY,G,ECmCU,CAAlD,EAAK,EAAL,E,EDnC2B,CCyBnB,CAAR,CDzBP,EDIO,E,6DCEP,E,KAAS,E,KAAA,G,IAAmB,E,KAAS,E,KC6BF,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ED7BE,G,EC6BoB,CAAlD,EAAK,EAAL,E,ED7BqB,C,KAAR,CAApB,EDFO,E,6DCQP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KCuBL,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EDvBK,G,ECuBiB,CAAlD,EAAK,EAAL,EDvBwB,EG5ClB,EAAc,EAAd,CAAmB,UAApB,CACC,EAAa,UAAb,CAAoC,EAArC,CACA,CAAR,EAEW,EAAN,CAAY,QAAb,CACC,EAAI,QAAJ,CAA2B,EAA5B,CAEW,CAAO,EAAf,CHqCX,EDRO,E,qDAdG,E,OACV,E,KAAY,E,KACZ,E,KAAe,E,UACR,E,+CKnCqB,E,KHwEb,GGxEf,E,EACI,E,KAAc,E,KH4EiB,E,EG5EjB,G,EH4EuC,CAAlD,EAAK,EAAL,EG5EH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL4CK,E,sDKrCqB,E,KH+Db,GG/Df,E,EACI,E,KAAc,E,KHmEiB,E,EGnEjB,G,EHmEuC,CAAlD,EAAK,EAAL,EGnEH,EAA2B,EAA3B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELmCK,E,sDK5BqB,E,KHsDb,GGtDf,E,EACI,E,KAAc,E,KH0DiB,E,EG1DjB,G,EH0DuC,CAAlD,EAAK,EAAL,EG1DH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,EL0BK,E,sDKnBqB,E,KH6Cb,GG7Cf,E,EACI,E,KAAc,E,KHiDiB,E,EGjDjB,G,EHiDuC,CAAlD,EAAK,EAAL,EGjDH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELiBK,E,sDKVqB,E,KHoCb,GGpCf,E,EACI,E,KAAc,E,KHwCiB,E,EGxCjB,G,EHwCuC,CAAlD,EAAK,EAAL,EGxCH,EAA0B,EAA1B,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELQK,E,sDKDqB,E,KH2Bb,GG3Bf,E,EACI,E,KAAc,E,KH+BiB,E,EG/BjB,G,EH+BuC,CAAlD,EAAK,EAAL,EG/BH,EAAyB,EAAzB,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELDK,E,qDKQC,E,YHuB2B,E,EGvBb,G,EHuBmC,CAAlD,EAAK,EAAL,EGvBH,E,EAA4C,EHkBjC,G,EAAA,GGlBX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELTK,E,qDKgBC,E,YHe2B,E,EGfb,G,EHemC,CAAlD,EAAK,EAAL,EGfH,E,EAA6C,EHUlC,G,EAAA,GGVX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjBK,E,qDKwBC,E,YHO2B,E,EGPb,G,EHOmC,CAAlD,EAAK,EAAL,EGPH,E,EAA6C,EHElC,G,EAAA,GGFX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELzBK,E,qDKgCC,E,YHD2B,E,EGCb,G,EHDmC,CAAlD,EAAK,EAAL,EGCH,E,EAA4C,EHNjC,G,EAAA,GGMX,CAAJ,E,EACoB,E,QAAX,E,OAAP,ELjCK,E,sDKwCH,E,KAAc,E,KHTiB,E,EGSjB,G,EHTuC,CAAlD,EAAK,EAAL,EGSH,E,IAA2B,E,KAAc,E,KHTV,E,EGSU,G,EHTY,CAAlD,EAAK,EAAL,EGSwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzCK,E,sDKgDH,E,KAAc,E,KHjBiB,E,EGiBjB,G,EHjBuC,CAAlD,EAAK,EAAL,EGiBH,E,IAA2B,E,KAAc,E,KHjBV,E,EGiBU,G,EHjBY,CAAlD,EAAK,EAAL,EGiBwB,EAA3B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjDK,E,sDKwDH,E,KAAc,E,KHzBiB,E,EGyBjB,G,EHzBuC,CAAlD,EAAK,EAAL,EGyBH,E,IAAyB,E,KAAc,E,KHzBR,E,EGyBQ,G,EHzBc,CAAlD,EAAK,EAAL,EGyBsB,EAAzB,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzDK,E,sDKgEC,E,KAAc,E,KHjCa,E,EGiCb,G,EHjCmC,CAAlD,EAAK,EAAL,EGiCH,E,IAAkC,E,KAAc,E,KHjCjB,E,EGiCiB,G,EHjCK,CAAlD,EAAK,EAAL,EGiC2B,EAA9B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjEK,E,sDKwEH,E,KAAc,E,KHzCiB,E,EGyCjB,G,EHzCuC,CAAlD,EAAK,EAAL,EGyCH,E,IAA0B,E,KAAc,E,KHzCT,E,EGyCS,G,EHzCa,CAAlD,EAAK,EAAL,EGyCuB,EAA1B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELzEK,E,sDKgFC,E,KAAc,E,KHjDa,E,EGiDb,G,EHjDmC,CAAlD,EAAK,EAAL,EGiDH,E,IAAmC,E,KAAc,E,KHjDlB,E,EGiDkB,G,EHjDI,CAAlD,EAAK,EAAL,EGiD4B,EAA/B,GAAJ,E,EACoB,E,QAAX,E,OAAP,ELjFK,E,mDM/CgD,E,QAAX,E,qDNwClC,E,OACV,E,KAAY,E,KACZ,E,KAAU,E,UACH,E,8CMvCa,E,YJ0Ee,E,EI1ED,G,EJ0EuB,CAAlD,EAAK,EAAL,EI1Ea,E,EAAuC,EJqE5C,G,EAAA,G,CIrEC,CACT,E,qDAKP,E,YAAc,G,IAAyB,EJ+DxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GI/Df,E,EACkB,E,QAAX,E,sDAKa,E,YJ8De,E,EI9DD,G,EJ8DuB,CAAlD,EAAK,EAAL,EI9Da,E,EAAuC,EJyD5C,G,EAAA,G,CIzDC,C,EAChB,E,KAAc,E,KAAA,G,IAAyB,EJwDxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GIxDf,EACO,E,qDCjBP,E,YAAc,G,IAAe,E,KAAJ,G,IAAmB,EAAJ,G,EL6EL,E,EAAsB,CAAlD,EAAK,EAAL,EK7EkB,E,EAAe,GAAe,EAAf,CAAf,CAAzB,EP8CO,E,qDOxCP,E,YAAc,G,IAAyB,ELkExB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GKlEf,EPwCO,E,+OFpB+B,E,QACC,E,gGUuDjB,E,UAAmC,EAAnB,GAAQ,E,KAAR,CAAuC,EAAvC,CAAlC,CADU,GAAZ,EAG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,E,KAAA,G,IAAW,E,KLkBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKlBL,G,EAEe,E,iBAAV,E,0DTuIO,E,OAA2B,EAAS,EAApC,E,OACF,E,OACV,E,KAAU,E,gCACL,E,oBAAD,CAAJ,E,EACE,E,KAAO,E,mBAAU,EAAV,E,MACP,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAc,E,qBAAU,E,EAAf,CAAsB,EAAvB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,MACR,E,KAAA,E,YAAY,E,qBAAU,E,EAAd,CAAqB,EAArB,C,YAEH,E,wDS/IM,E,KAAc,E,YAAd,G,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLSQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKTL,G,EAEe,E,iBAAV,E,+DAKa,E,YLEe,E,EKFD,G,ELEuB,CAAlD,EAAK,EAAL,EKFa,E,EAAuC,ELH5C,G,EAAA,G,CKGC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLRe,E,EKQD,G,ELRuB,CAAlD,EAAK,EAAL,EKQa,E,EAAuC,ELb5C,G,EAAA,G,CKaC,CAAhB,E,EACe,E,OAAa,EAAb,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLXQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKWL,G,EAEe,E,iBAAV,E,+DAKa,E,YLlBe,E,EKkBD,G,ELlBuB,CAAlD,EAAK,EAAL,EKkBa,E,EAAuC,ELvB5C,G,EAAA,G,CKuBC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLrBQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKqBL,G,EAEe,E,iBAAV,E,+DAKa,E,YL5Be,E,EK4BD,G,EL5BuB,CAAlD,EAAK,EAAL,EK4Ba,E,EAAuC,ELjC5C,G,EAAA,G,CKiCC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL/BQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK+BL,G,EAEe,E,iBAAV,E,+DAKa,E,YLtCe,E,EKsCD,G,ELtCuB,CAAlD,EAAK,EAAL,EKsCa,E,EAAuC,EL3C5C,G,EAAA,G,CK2CC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLzCQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKyCL,G,EAEe,E,iBAAV,E,+DAKa,E,YLhDe,E,EKgDD,G,ELhDuB,CAAlD,EAAK,EAAL,EKgDa,E,EAAuC,ELrD5C,G,EAAA,G,CKqDC,CAAhB,E,EACe,E,OAAc,EAAd,E,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KLnDQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KKmDL,G,EAEe,E,iBAAV,E,+DAKa,E,YL1De,E,EK0DD,G,EL1DuB,CAAlD,EAAK,EAAL,EK0Da,E,EAAuC,EL/D5C,G,EAAA,G,CK+DC,CAAhB,E,EACe,E,OAAc,EAAd,G,OACV,E,oBAAD,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KL7DQ,E,EAAsB,CAAlD,EAAK,EAAL,E,KK6DL,G,EAEe,E,iBAAV,E,6DI5IP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT6EJ,E,ES7EI,G,ET6EkB,CAAlD,EAAK,EAAL,ES7EkB,E,IAAuC,ETwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ES7EkB,E,ETwEV,GSxEU,CAAzB,EX8CO,E,6DWxCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTuEJ,E,ESvEI,G,ETuEkB,CAAlD,EAAK,EAAL,ESvEkB,E,IAAuC,ETkEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESvEkB,E,ETkEV,GSlEU,CAAzB,EXwCO,E,6DWlCP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTiEJ,E,ESjEI,G,ETiEkB,CAAlD,EAAK,EAAL,ESjEkB,E,IAAuC,ET4DjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,ESjEkB,E,ET4DV,GS5DU,CAAzB,EXkCO,E,6DW5BP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT2DJ,E,ES3DI,G,ET2DkB,CAAlD,EAAK,EAAL,ES3DkB,E,IAAyB,E,KAAc,E,KT2D7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES3D6B,G,ET2DP,CAAlD,EAAK,EAAL,ES3D2C,EAAzB,GAAzB,EX4BO,E,6DWtBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTqDJ,E,ESrDI,G,ETqDkB,CAAlD,EAAK,EAAL,ESrDkB,E,IAAyB,E,KAAc,E,KTqD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ESrD6B,G,ETqDP,CAAlD,EAAK,EAAL,ESrD2C,EAAzB,GAAzB,EXsBO,E,6DWhBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KT+CJ,E,ES/CI,G,ET+CkB,CAAlD,EAAK,EAAL,ES/CkB,E,IAAyB,E,KAAc,E,KT+C7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES/C6B,G,ET+CP,CAAlD,EAAK,EAAL,ES/C2C,EAAzB,GAAzB,EXgBO,E,6DWVP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTyCJ,E,ESzCI,G,ETyCkB,CAAlD,EAAK,EAAL,ESzCkB,E,IAA0B,E,KAAc,E,KTyC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESzCkB,E,ETyCU,E,ESzC8B,G,ETyCR,CAAlD,EAAK,EAAL,ESzC4C,E,EAAD,CAAzB,CAAzB,EXUO,E,6DWJP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KTmCJ,E,ESnCI,G,ETmCkB,CAAlD,EAAK,EAAL,ESnCkB,E,IAA0B,E,KAAc,E,KTmC9B,E,EAAsB,CAAlD,EAAK,EAAL,ESnCkB,E,ETmCU,E,ESnC8B,G,ETmCR,CAAlD,EAAK,EAAL,ESnC4C,E,EAAD,CAAzB,CAAzB,EXIO,E,6DWEP,E,KAAc,E,KAAA,G,IAAa,E,KAAc,E,KT6BN,E,ES7BM,G,ET6BgB,CAAlD,EAAK,EAAL,ES7BoB,E,IAAyB,E,KAAc,E,KT6B/B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,ES7B+B,G,ET6BT,CAAlD,EAAK,EAAL,ES7B6C,EAAzB,G,EAAF,CAAzB,EXFO,E,sDY9CG,E,YV6EyB,E,EU7EX,G,EV6EiC,CAAlD,EAAK,EAAL,EU7EG,EAAV,E,EACwB,E,KVuET,GUvEf,E,EACA,E,KAAc,E,KV2EqB,E,EU3ErB,G,EV2E2C,CAAlD,EAAK,EAAL,EU3EwC,EAAJ,E,CAAJ,CAAvC,EZ4CO,E,6DYtCP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVqEtB,E,EUrEsB,G,EVqEA,CAAlD,EAAK,EAAL,EUrEoC,E,IAAyB,E,KVqEjC,E,EAAsB,CAAlD,EAAK,EAAL,EUrEoC,E,MAAJ,CAAvC,EZsCO,E,sDYhCU,E,KAAJ,GAAc,MAAd,C,EAA+B,E,KAAc,E,KV+DvB,E,EU/DuB,G,EV+DD,CAAlD,EAAK,EAAL,EU/DqC,EAAhC,CAAZ,E,EACA,E,KAAc,E,KV8DqB,E,EU9DrB,G,EV8D2C,CAAlD,EAAK,EAAL,E,EU9DgC,CAAvC,EZ+BO,E,sDYzBU,E,YVwDkB,E,EUxDJ,G,EVwD0B,CAAlD,EAAK,EAAL,EUxDU,E,EAAuC,EVmDzC,G,EAAA,GUnDE,CAAjB,E,EACA,E,KAAc,E,KVuDqB,E,EUvDrB,G,EVuD2C,CAAlD,EAAK,EAAL,EUvDkB,EAAzB,EZwBO,E,6DYlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KViDJ,E,EUjDI,G,EViDkB,CAAlD,EAAK,EAAL,EUjDkB,E,IAAuC,EV4CjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,EUjDkB,E,EV4CV,GU5CU,CAAzB,EZkBO,E,sDYZmB,E,KVsCX,G,EUtCqB,E,KAAc,E,KV2Cf,E,EU3Ce,G,EV2CO,CAAlD,EAAK,EAAL,EU3C6B,EAAxB,CAAZ,E,EACA,E,KAAc,E,KV0CqB,E,EU1CrB,G,EV0C2C,CAAlD,EAAK,EAAL,EU1CkB,EAAzB,EZWO,E,wDYLO,E,KAAc,E,KVoCO,E,EUpCP,G,EVoC6B,CAAlD,EAAK,EAAL,E,EUpCG,CAAV,E,EACc,E,KAAc,E,KVmCO,E,EUnCP,G,EVmC6B,CAAlD,EAAK,EAAL,E,EUnCG,CAAV,E,EACA,E,KAAc,E,KVkCqB,E,EUlCrB,G,EVkC2C,CAAlD,EAAK,EAAL,EUlCgC,EAAI,EAAJ,CV6BhC,CU7BP,EZGO,E,6DYGP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KV4BtB,E,EU5BsB,G,EV4BA,CAAlD,EAAK,EAAL,EU5BoC,EAAyB,MAAzB,C,IAAuC,E,KAAc,E,KV4B7D,E,EAAsB,CAAlD,EAAK,EAAL,EU5BoC,E,EV4BR,E,EU5B6D,G,EV4BvC,CAAlD,EAAK,EAAL,E,EU5BuE,E,CAAvC,CAAvC,EZHO,E,6DYSP,E,KAAc,E,KAAA,G,IAA6B,E,KAAc,E,KVsBtB,E,EUtBsB,G,EVsBA,CAAlD,EAAK,EAAL,EUtBoC,E,IAAyB,E,KAAc,E,KVsB/C,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUtB+C,G,EVsBzB,CAAlD,EAAK,EAAL,EUtB6D,EAAzB,E,CAAJ,CAAvC,EZTO,E,wDYeO,E,KAAc,E,KVgBO,E,EUhBP,G,EVgB6B,CAAlD,EAAK,EAAL,E,EUhBG,CAAV,EACA,E,EAGgB,E,KAAc,E,KVYK,E,EUZL,G,EVY2B,CAAlD,EAAK,EAAL,E,EUZK,CAAV,E,EACA,E,KAAc,E,KVWmB,E,EUXnB,G,EVWyC,CAAlD,EAAK,EAAL,EUXkC,EAAI,EAAJ,CVMlC,CUNL,G,EAHA,E,KAAc,E,KVcmB,E,EUdnB,G,EVcyC,CAAlD,EAAK,EAAL,EUdoB,EAAzB,GZjBK,E,sDY2BqB,E,KAAc,E,KVIP,E,EUJO,G,EVIe,CAAlD,EAAK,EAAL,E,EUJiB,CAAxB,E,EAC4B,E,KAAc,E,KVGP,E,EUHO,G,EVGe,CAAlD,EAAK,EAAL,E,EUHiB,CAAxB,EACI,CAAJ,E,EACE,E,KAAc,E,KVCmB,E,EUDnB,G,EVCyC,CAAlD,EAAK,EAAL,EUDoB,EAAzB,GACqB,E,MAAA,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVDmB,E,EUCnB,G,EVDyC,CAAlD,EAAK,EAAL,EUCoB,EAAzB,G,EAEA,E,KAAc,E,KVHmB,E,EUGnB,G,EVHyC,CAAlD,EAAK,EAAL,EUGoB,EAAI,EAAJ,CAAzB,IZlCK,E,wDYyCO,E,KAAc,E,KVVO,E,EUUP,G,EVV6B,CAAlD,EAAK,EAAL,E,EUUG,CAAV,E,EACc,E,KAAc,E,KVXO,E,EUWP,G,EVX6B,CAAlD,EAAK,EAAL,E,EUWG,CAAV,EACI,EAAJ,E,EAGE,E,KAAc,E,KVfmB,E,EUenB,G,EVfyC,CAAlD,EAAK,EAAL,EUekC,EAAI,EAAJ,CVpBlC,CUoBL,G,EAFA,E,KAAc,E,KVbmB,E,EUanB,G,EVbyC,CAAlD,EAAK,EAAL,EUakC,EVlBlC,CUkBL,GZ5CK,E,wDYqDO,E,KAAc,E,KVtBO,E,EUsBP,G,EVtB6B,CAAlD,EAAK,EAAL,E,EUsBG,CAAV,E,EACc,E,KAAc,E,KVvBO,E,EUuBP,G,EVvB6B,CAAlD,EAAK,EAAL,E,EUuBG,CAAV,EACA,EAEuB,EAAM,MAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV3BmB,E,EU2BnB,G,EV3ByC,CAAlD,EAAK,EAAL,EU2BoB,EAAzB,G,EAEA,E,KAAc,E,KV7BmB,E,EU6BnB,G,EV7ByC,CAAlD,EAAK,EAAL,E,EU6BoB,C,EAAS,CAAT,CAAzB,I,EAJA,E,KAAc,E,KVzBmB,E,EUyBnB,G,EVzByC,CAAlD,EAAK,EAAL,E,EUyBoB,CAAzB,GZxDK,E,6DYmEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVpCJ,E,EUoCI,G,EVpCkB,CAAlD,EAAK,EAAL,EUoCkB,E,IAAyB,E,KAAc,E,KVpC7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUoC6B,G,EVpCP,CAAlD,EAAK,EAAL,EUoC2C,EAAzB,GAAzB,EZnEO,E,6DYyEP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV1CJ,E,EU0CI,G,EV1CkB,CAAlD,EAAK,EAAL,EU0CkB,E,IAAyB,E,KAAc,E,KV1C7B,E,EAAsB,CAAlD,EAAK,EAAL,EU0CkB,E,EV1CU,E,EU0C6B,G,EV1CP,CAAlD,EAAK,EAAL,EU0C2C,EAAzB,CAAzB,EZzEO,E,6DY+EP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVhDJ,E,EUgDI,G,EVhDkB,CAAlD,EAAK,EAAL,EUgDkB,E,IAAyB,E,KAAc,E,KVhD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EUgD6B,G,EVhDP,CAAlD,EAAK,EAAL,EUgD2C,EAAzB,GAAzB,EZ/EO,E,6DYqFH,E,KAAc,E,KVtDiB,E,EUsDjB,G,EVtDuC,CAAlD,EAAK,EAAL,EUsDH,GAAJ,E,EACE,E,KAAc,E,KVvDmB,E,EUuDnB,G,EVvDyC,CAAlD,EAAK,EAAL,EUuDoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVzDN,E,EUyDM,G,EVzDgB,CAAlD,EAAK,EAAL,EUyDoB,E,IAAyB,E,KAAc,E,KVzD/B,E,EAAsB,CAAlD,EAAK,EAAL,EUyDoB,E,EVzDQ,E,EUyD+B,G,EVzDT,CAAlD,EAAK,EAAL,EUyD6C,EAAzB,CAAzB,GZxFK,E,sDY+FO,E,KAAc,E,KVhEO,E,EUgEP,G,EVhE6B,CAAlD,EAAK,EAAL,EUgEG,EAAV,E,EACc,E,KAAc,E,KVjEO,E,EUiEP,G,EVjE6B,CAAlD,EAAK,EAAL,EUiEG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KVnEmB,E,EUmEnB,G,EVnEyC,CAAlD,EAAK,EAAL,EUmEoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KVrEmB,E,EUqEnB,G,EVrEyC,CAAlD,EAAK,EAAL,EUqEoB,EAAzB,G,EAEA,E,KAAc,E,KVvEmB,E,EUuEnB,G,EVvEyC,CAAlD,EAAK,EAAL,EUuEoB,EAAI,EAAJ,CAAzB,IZtGK,E,6DY6GH,E,KAAc,E,KV9EiB,E,EU8EjB,G,EV9EuC,CAAlD,EAAK,EAAL,EU8EH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KV/EN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EU+EM,G,EV/EgB,CAAlD,EAAK,EAAL,EU+EoB,EAAzB,G,EAEA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KVjFN,E,EUiFM,G,EVjFgB,CAAlD,EAAK,EAAL,EUiFoB,E,IAAyB,E,KAAc,E,KVjF/B,E,EAAsB,CAAlD,EAAK,EAAL,EUiFoB,E,EVjFQ,E,EUiF+B,G,EVjFT,CAAlD,EAAK,EAAL,EUiF6C,EAAzB,CAAzB,GZhHK,E,sDYuHO,E,KAAc,E,KVxFO,E,EUwFP,G,EVxF6B,CAAlD,EAAK,EAAL,EUwFG,EAAV,E,EACc,E,KAAc,E,KVzFO,E,EUyFP,G,EVzF6B,CAAlD,EAAK,EAAL,EUyFG,EAAV,EACI,CAAJ,E,EACE,E,KAAc,E,KV3FmB,E,EU2FnB,G,EV3FyC,CAAlD,EAAK,EAAL,EU2FoB,EAAzB,GACqB,EAAM,WAAN,CAAZ,EAAM,EAAN,EAAJ,E,EACL,E,KAAc,E,KV7FmB,E,EU6FnB,G,EV7FyC,CAAlD,EAAK,EAAL,EU6FoB,EAAzB,G,EAEA,E,KAAc,E,KV/FmB,E,EU+FnB,G,EV/FyC,CAAlD,EAAK,EAAL,EU+FoB,EAAI,EAAJ,CAAzB,IZ9HK,E,6DYqIP,E,KAAc,E,KAAA,G,IAA8B,E,KAAc,E,KVtGvB,E,EUsGuB,G,EVtGD,CAAlD,EAAK,EAAL,EUsGiC,E,IAAiC,E,KAAc,E,KVtGpD,E,EAAsB,CAAlD,EAAK,EAAL,E,IAA4B,E,EUsGoD,G,EVtG9B,CAAlD,EAAK,EAAL,EUsG8D,EVpJrE,EADA,EAEQ,EAAJ,CAAJ,EAEU,E,EAAD,CAAK,EAAL,CAAP,EADmB,G,GAAnB,EAGE,EAAI,EAAJ,CAAJ,EAEU,E,EAAD,CAAK,EAAL,CAAP,EADoB,EAAD,E,GAIrB,EACuC,EA7Bf,EAAL,CAAnB,EADkB,EAAI,MAAJ,CAAlB,EAKgB,CAAhB,EAyBiC,EA/BT,EAAL,CAAnB,EAGkB,EAAI,MAAJ,CAAlB,EAIgB,CAAhB,EAyBuB,EAAP,GACG,EAjCnB,EAEA,EAMiB,CAFjB,EAK8B,EAAX,CAAZ,CAJP,EAIgD,EAAX,CAA9B,CAFyB,EAAU,MAAV,CAJjB,EAAO,EAAP,CAIU,EAAV,CAAD,CAA4C,EAAU,MAAV,CAA5C,CAEkD,EAAT,CAAhD,C,EAsBE,EAAP,GAG4B,EAlCN,EAAL,CAAnB,EADkB,EAAI,MAAJ,CAAlB,EAKgB,CAAhB,EA8BwB,EApCA,EAAL,CAAnB,EAEA,EAMiB,CAFjB,EAK8B,EAAX,CAAZ,CARW,EAAI,MAAJ,CAAlB,EAIgB,GAAhB,EAIgD,EAAX,CAA9B,CAFyB,EAAU,MAAV,CAJV,EAAP,GAIU,EAAV,CAAD,CAA4C,EAAU,MAAV,CAA5C,CAEkD,EAAT,CAAhD,EU6JP,EZrIO,E,6DY2IP,E,KAAc,E,KAAA,G,IAA4B,E,KAAc,E,KV5GrB,E,EU4GqB,G,EV5GC,CAAlD,EAAK,EAAL,EU4GmC,E,IAAwB,E,KAAc,E,KV5G7C,E,EU4G6C,G,EV5GvB,CAAlD,EAAK,EAAL,EU4G2D,EV5K/C,EAAK,EAAL,CAAnB,EAFmB,EAAK,EAAL,CAAnB,EAGkB,EAAI,MAAJ,CAAlB,EAIgB,CAAhB,E,EA2DmC,E,EAAsB,CAAlD,EAAK,EAAL,EA1DkB,EAAR,GAPC,EAAI,MAAJ,CAAlB,EAKuB,EAAP,CAAhB,EAK8B,EAAX,CAAZ,CAA8B,EAAW,EAAX,CAA9B,CAFyB,EAAU,MAAV,CAJjB,EAAO,EAAP,CAIU,EAAV,CAAD,CAA4C,EAAU,MAAV,CAA5C,CAEkD,EAAT,CAAhD,CUmKP,EZ3IO,E,6DYiJP,E,KAAc,E,KVlHqB,E,EUkHrB,G,EVlH2C,CAAlD,EAAK,EAAL,E,IUkH6C,E,KAAc,E,KVlH/B,E,EUkH+B,G,EVlHT,CAAlD,EAAK,EAAL,EUkHyC,E,IAA6B,E,KAAc,E,KVlHxD,E,EUkHwD,G,EVlHlC,CAAlD,EAAK,EAAL,EUkHsE,E,EV5IzE,EAAI,EAAJ,CAAJ,EACqB,E,EAAD,CAAK,EAAL,CAAlB,EAxCoB,MAAJ,CAAlB,EAyCuC,EAxCf,EAAL,CAAnB,EAIgB,CAAhB,EAoCiC,EA1CT,EAAL,CAAnB,EAGkB,EAAI,MAAJ,CAAlB,EAIgB,CAAhB,EAoCuB,EAFrB,EAEc,CACG,EA5CnB,EAQyB,EAAR,CAFjB,EAK8B,EAAX,CAAZ,CAJP,EAIgD,EAAX,CAA9B,CAFyB,EAAU,MAAV,CAJjB,EAAO,EAAP,CAIU,EAAV,CAAD,CAA4C,EAAU,MAAV,CAA5C,CAEkD,EAAT,CAAhD,C,EAiCE,EAAP,GA3CgB,EAAI,MAAJ,CAAlB,EA6C2B,EA5CH,EAAL,CAAnB,EAIgB,CAAhB,EAwCwB,EA9CA,EAAL,CAAnB,EAGkB,EAAI,MAAJ,CAAlB,EAIgB,CAAhB,EAPA,EAQyB,EAAR,CAFjB,EAK8B,EAAX,CAAZ,CAJP,EAIgD,EAAX,CAA9B,CAFyB,EAAU,MAAV,CAJjB,EAAO,EAAP,CAIU,EAAV,CAAD,CAA4C,EAAU,MAAV,CAA5C,CAEkD,EAAT,CAAhD,EUyKP,EZjJO,E,sDYuJO,E,KAAc,E,KVxHO,E,EUwHP,G,EVxH6B,CAAlD,EAAK,EAAL,EUwHG,EAAV,E,EACc,E,KAAc,E,KVzHO,E,EUyHP,G,EVzH6B,CAAlD,EAAK,EAAL,EUyHG,EAAV,E,EACA,E,KAAc,E,KV1HqB,E,EU0HrB,G,EV1H2C,CAAlD,EAAK,EAAL,EU0H0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZzJO,E,sDY+JG,E,KAAc,E,KVhIW,E,EUgIX,G,EVhIiC,CAAlD,EAAK,EAAL,EUgIG,EAAV,E,EACU,E,KAAc,E,KVjIW,E,EUiIX,G,EVjIiC,CAAlD,EAAK,EAAL,EUiIG,EAAV,E,EACA,E,KAAc,E,KVlIqB,E,EUkIrB,G,EVlI2C,CAAlD,EAAK,EAAL,EUkI0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZjKO,E,sDYuKO,E,KAAc,E,KVxIO,E,EUwIP,G,EVxI6B,CAAlD,EAAK,EAAL,EUwIG,EAAV,E,EACc,E,KAAc,E,KVzIO,E,EUyIP,G,EVzI6B,CAAlD,EAAK,EAAL,EUyIG,EAAV,E,EACA,E,KAAc,E,KV1IqB,E,EU0IrB,G,EV1I2C,CAAlD,EAAK,EAAL,EU0I0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZzKO,E,sDY+KG,E,KAAc,E,KVhJW,E,EUgJX,G,EVhJiC,CAAlD,EAAK,EAAL,EUgJG,EAAV,E,EACU,E,KAAc,E,KVjJW,E,EUiJX,G,EVjJiC,CAAlD,EAAK,EAAL,EUiJG,EAAV,E,EACA,E,KAAc,E,KVlJqB,E,EUkJrB,G,EVlJ2C,CAAlD,EAAK,EAAL,EUkJ0B,EAAI,EAAZ,EAAI,EAAJ,EAAzB,EZjLO,E,sCatCgD,E,mCb8C7C,E,OACV,E,KAAY,E,KACZ,E,KAAW,E,KACX,E,KAAa,E,gFLqBJ,E,2DmBxEK,E,KAAZ,E,+CjBsDI,E,iBAAA,GAAmB,EAAnB,CAAJ,E,EACS,E,wCF2MC,E,QAAV,EACU,EAAN,CAAJ,EAAkC,I,eAChB,E,UAA4B,E,GAAV,EAAkB,EAAlB,CAAlB,CAAR,G,OACV,E,KAAe,E,iBACR,EE/ML,E,EAGsB,E,QAAsB,EAAtB,CAAxB,E,EAEwB,E,GAApB,E,KAAA,CAAJ,E,aACE,I,EAIW,EAAkB,MAAlB,GAAoD,GAAf,GAA4B,G,OAC9E,E,KAAA,E,UAAuB,E,MACJ,E,UAAqB,E,KAAjC,E,gEWiCK,E,KAAU,EADC,EC1Ed,MAAN,CADQ,M,CAEA,EAAR,CAAc,MAAd,CAAL,IACU,EAAL,C,CACA,M,CAAL,IACU,EAAL,C,CACA,M,CAAL,IACU,EAAL,C,CDoEH,EACY,EAAZ,EACA,E,EACgB,E,GAAd,E,KAES,EAAyB,EAA0B,EADxC,G,EAKhB,E,UAAsB,E,QAAtB,CAAJ,E,EACE,E,KACE,E,UAAoB,K,KAAuB,EAAvB,CAAuC,EAAvC,CAApB,G,EACK,E,WACA,K,KAAoB,EAApB,CAAyB,EAA1B,E,kCAuCqB,EAAiB,EAAvB,CAAzB,EACsD,EAArB,CAAhB,G,OACQ,EAAqB,EAArB,CAAqC,EAArC,CAAzB,EACsD,EAArB,CAAhB,G,OAGc,E,QAA/B,E,EAC6B,E,GAAhB,E,KAAqC,EAA5B,CAAT,CAAb,EACa,EAAb,EACA,EAAiB,EAAV,G,EACU,E,GACa,EAAtB,C,CAAN,EACiB,EACG,E,GAAlB,E,KAEiB,E,QAAjB,E,KAGA,EADuB,EADqB,EAAf,EC9IxB,MAAN,CADQ,M,CAEA,EAAR,CAAc,MAAd,CAAL,EACU,EAAL,CADL,E,CAEK,M,CAAL,EACU,EAAL,CADL,E,CAEK,M,CAAL,EACU,EAAL,CADL,E,CDyI2B,CAC0D,EAAxB,CAAhC,CAAvB,EACsB,G,GACT,EAAkB,EAA/B,GACA,EAAU,E,CAAV,GAEF,EAAU,E,CAAV,E,MAGF,E,KAAe,E,oBACf,E,KAAmB,E,KACnB,E,KAAe,E,oBACf,E,KAAuB,E,KACvB,E,KAAqB,E,uBAhEL,E,iBACyD,E,KAAA,E,kBAArC,E,EAA6D,EAAhC,CAAvD,CAAR,EAEY,E,KAIE,E,GAAd,E,KAES,EAAyB,EAA0B,EADxC,E,EAGlB,E,KAAA,E,kBAEoC,E,YAAmC,EAAnB,GACtD,E,EAD8D,E,KAAR,CAAuC,EAAvC,CAAlC,CAApB,EACmB,G,GACN,EAAe,EAA5B,I,kEK7HQ,E,KAAgB,E,KAAc,E,OXiEP,E,EWjEO,G,EXiEe,CAAlD,EAAK,EAAL,E,EWjEiB,C,6Bf0HE,E,OACxB,E,sBACI,GAAJ,E,EAIoB,E,KAAJ,GAAwB,E,CAAxB,CAAhB,EACe,MAAX,CAAJ,E,EACE,E,iBAAgC,E,QAGlC,E,YAGgB,E,GADK,EAAU,EAAV,CAAgB,E,CAArB,CAAhB,E,KACI,CAAJ,E,EAIa,E,QAAyB,EAAzB,CAAR,E,EAAoC,EAAK,EAAL,C,IAC1B,E,mBAAA,G,OACb,E,iBAAyC,E,GAAd,E,EAAT,E,WAAH,E,KAFsC,E,GAAA,E,MAKvD,E,KAAyB,E,WAClB,E,OehJL,E,oBAAJ,E,EACmB,E,iBAAV,E,OAAP,E,EAEF,E,KAAc,E,KAAA,G,IAAW,E,KX4DU,E,EAAsB,CAAlD,EAAK,EAAL,E,KW5DP,Eb6BO,E,8Ee9CP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb6EJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea7EI,G,Eb6EkB,CAAlD,EAAK,EAAL,Ea7EkB,EAAzB,Ef8CO,E,sDexCH,E,KAAc,E,KbuEiB,E,EavEjB,G,EbuEuC,CAAlD,EAAK,EAAL,EavEH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EbiE1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GajEb,GfuCK,E,sDehCH,E,KAAc,E,Kb+DiB,E,Ea/DjB,G,Eb+DuC,CAAlD,EAAK,EAAL,Ea/DH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAyB,EbyD1B,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,GazDb,Gf+BK,E,6DexBH,E,KAAc,E,KbuDiB,E,EavDjB,G,EbuDuC,CAAlD,EAAK,EAAL,EavDH,GAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KbsDN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EatDM,G,EbsDgB,CAAlD,EAAK,EAAL,EatDoB,EAAzB,GfuBK,E,6DehBH,E,KAAc,E,Kb+CiB,E,Ea/CjB,G,Eb+CuC,CAAlD,EAAK,EAAL,Ea/CH,EAA2B,EAA3B,CAAJ,E,EACE,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,Kb8CN,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ea9CM,G,Eb8CgB,CAAlD,EAAK,EAAL,Ea9CoB,EAAzB,GfeK,E,6DgB9CP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,Kd6EL,E,Ec7EK,G,Ed6EiB,CAAlD,EAAK,EAAL,Ec7EwB,E,IAAiC,EdwEjD,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,Ec7EwB,E,EdwEhB,GcvBN,CAjDT,EhB8CO,E,6DgBxCP,E,YAAS,G,IAAoC,E,KdkE9B,G,IclEuC,E,KAAS,E,KduE5B,E,EAAsB,CAAlD,EAAK,EAAL,EALQ,E,EAKoB,E,EcvE4B,G,EduEN,CAAlD,EAAK,EAAL,EcvE+C,EA2C7C,CA3CT,EhBwCO,E,6DgBlCP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdiE1B,E,EcjE0B,G,EdiEJ,CAAlD,EAAK,EAAL,E,EcjEyC,C,IAA4B,EAyCtD,G,EdwBa,E,EAAsB,CAAlD,EAAK,EAAL,EcjEyC,E,EAyC1B,GAAb,CdmBF,Cc5DP,EhBkCO,E,6DgB5BP,E,YAAS,G,IAA2C,E,KAmCjC,G,IAnC8C,E,KAAS,E,Kd2DvC,E,EAAsB,CAAlD,EAAK,EAAL,EcxBY,E,EdwBgB,E,Ec3DuC,G,Ed2DjB,CAAlD,EAAK,EAAL,E,Ec3DsD,CAmCpD,CdmBF,CctDP,EhB4BO,E,6DgBtBP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdqDL,E,EcrDK,G,EdqDiB,CAAlD,EAAK,EAAL,EcrDwB,E,IAAmB,E,KAAS,E,KdqDxB,E,EAAsB,CAAlD,EAAK,EAAL,EcrDwB,E,EdqDI,E,EcrDwB,G,EdqDF,CAAlD,EAAK,EAAL,EcrD2C,EAiCzC,CAjCT,EhBsBO,E,6DgBhBP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,Kd+C1B,E,Ec/C0B,G,Ed+CJ,CAAlD,EAAK,EAAL,E,Ec/CyC,C,IAA4B,E,KAAS,E,Kd+ClD,E,EAAsB,CAAlD,EAAK,EAAL,Ec/CyC,E,Ed+Cb,E,Ec/CkD,G,Ed+C5B,CAAlD,EAAK,EAAL,E,Ec/CiE,CA+B/D,CdWF,Cc1CP,EhBgBO,E,6DgBVP,E,KAAS,E,KAAA,G,IAAsB,E,KAAS,E,KdyCL,E,EczCK,G,EdyCiB,CAAlD,EAAK,EAAL,EczCwB,E,IAAmB,E,KAAS,E,KdyCxB,E,EAAsB,CAAlD,EAAK,EAAL,EczCwB,E,EdyCI,E,EczCwB,G,EdyCF,CAAlD,EAAK,EAAL,EczC2C,EAazC,CAbT,EhBUO,E,6DgBJP,E,KAAS,E,KAAA,G,IAA2C,E,KAAS,E,KdmC1B,E,EcnC0B,G,EdmCJ,CAAlD,EAAK,EAAL,E,EcnCyC,C,IAA4B,E,KAAS,E,KdmClD,E,EAAsB,CAAlD,EAAK,EAAL,EcnCyC,E,EdmCb,E,EcnCkD,G,EdmC5B,CAAlD,EAAK,EAAL,E,EcnCiE,CAW/D,CdmBF,Cc9BP,EhBIO,E,sDiB9CM,E,Yf6EsB,E,Ee7ER,G,Ef6E8B,CAAlD,EAAK,EAAL,Ee7EM,E,EAA2C,EfwEzC,G,EAAA,GexEF,CAAb,E,EACA,E,KAAc,E,Kf4EqB,E,Ee5ErB,G,Ef4E2C,CAAlD,EAAK,EAAL,Ee5EkB,GAAzB,EjB6CO,E,sDiBvCU,E,YfsEkB,E,EetEJ,G,EfsE0B,CAAlD,EAAK,EAAL,EetEM,E,EAA4C,EfiE1C,G,EAAA,GejEF,CAAb,E,EACA,E,KAAc,E,KfqEqB,E,EerErB,G,EfqE2C,CAAlD,EAAK,EAAL,EerEkB,GAAzB,EjBsCO,E,sDiBhCM,E,Yf+DsB,E,Ee/DR,G,Ef+D8B,CAAlD,EAAK,EAAL,Ee/DM,E,EAA2C,Ef0DzC,G,EAAA,Ge1DF,CAAb,E,EACA,E,KAAc,E,Kf8DqB,E,Ee9DrB,G,Ef8D2C,CAAlD,EAAK,EAAL,Ee9DkB,GAAzB,EjB+BO,E,sDiBzBU,E,YfwDkB,E,EexDJ,G,EfwD0B,CAAlD,EAAK,EAAL,EexDM,E,EAA4C,EfmD1C,G,EAAA,GenDF,CAAb,E,EACA,E,KAAc,E,KfuDqB,E,EevDrB,G,EfuD2C,CAAlD,EAAK,EAAL,EevDkB,GAAzB,EjBwBO,E,6DiBlBP,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KfiDJ,E,EejDI,G,EfiDkB,CAAlD,EAAK,EAAL,EejDkB,E,IAAyB,E,KAAc,E,KfiD7B,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EejD6B,G,EfiDP,CAAlD,EAAK,EAAL,EejD2C,EAAzB,IAAzB,EjBkBO,E,6DiBZP,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,Kf2CR,E,Ee3CQ,G,Ef2Cc,CAAlD,EAAK,EAAL,Ee3CkB,E,IAAkC,E,KAAc,E,Kf2CtC,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,Ee3CsC,G,Ef2ChB,CAAlD,EAAK,EAAL,Ee3CgD,EAA9B,IAAzB,EjBYO,E,wDkB3CW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhByEG,E,EgBzEH,G,EhByEyB,CAAlD,EAAK,EAAL,E,EgBzEO,CAAd,E,EACA,E,KAAc,E,KhBwEqB,E,EgBxErB,G,EhBwE2C,CAAlD,EAAK,EAAL,EgBxEgC,EAAS,EAAT,ChBmEhC,CgBnEP,ElByCO,E,wDkBnCW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBiEG,E,EgBjEH,G,EhBiEyB,CAAlD,EAAK,EAAL,E,EgBjEO,CAAd,E,EACA,E,KAAc,E,KhBgEqB,E,EgBhErB,G,EhBgE2C,CAAlD,EAAK,EAAL,EgBhEgC,EAAU,EAAV,ChB2DhC,CgB3DP,ElBiCO,E,sDkB3BW,E,QAAS,EAAb,CAAd,E,EACgC,E,KAAc,E,KhByDX,E,EgBzDW,G,EhByDW,CAAlD,EAAK,EAAL,E,EgBzDqB,CAA5B,E,EACA,E,KAAc,E,KhBwDqB,E,EgBxDrB,G,EhBwD2C,CAAlD,EAAK,EAAL,EgBxDkB,E,EAAS,CAAT,CAAzB,ElByBO,E,sDkBnBW,E,KAAc,E,KhBkDG,E,EgBlDH,G,EhBkDyB,CAAlD,EAAK,EAAL,EgBlDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhBiDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgBjD0C,EAAV,ChB4ChC,CgB5CP,ElBkBO,E,sDkBZW,E,KAAc,E,KhB2CG,E,EgB3CH,G,EhB2CyB,CAAlD,EAAK,EAAL,EgB3CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,K,EhB0CJ,E,EAAsB,CAAlD,EAAK,EAAL,E,KgB1C2C,EAAX,ChBqChC,CgBrCP,ElBWO,E,sDkBLW,E,YhBoCiB,E,EgBpCH,G,EhBoCyB,CAAlD,EAAK,EAAL,EgBpCW,E,GAAJ,CAAd,E,EAC0B,E,KhB8BX,GgB9Bf,E,EACA,E,KAAc,E,KhBkCqB,E,EgBlCrB,G,EhBkC2C,CAAlD,EAAK,EAAL,EgBlCoC,E,EAAO,C,CAAX,CAAvC,ElBGO,E,6DkBGW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhB2BJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgB3BI,G,EhB2BkB,CAAlD,EAAK,EAAL,EgB3BkB,E,EAA0B,CAA1B,CAAzB,ElBJO,E,6DkBUW,E,QAAS,EAAb,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBoBJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBpBI,G,EhBoBkB,CAAlD,EAAK,EAAL,EgBpBkB,E,EAA2B,CAA3B,CAAzB,ElBXO,E,sDkBiBW,E,QAAS,EAAb,CAAd,E,EACkB,E,KAAc,E,KhBaG,E,EgBbH,G,EhBayB,CAAlD,EAAK,EAAL,EgBbO,EAAd,E,EACA,E,KAAc,E,KhBYqB,E,EgBZrB,G,EhBY2C,CAAlD,EAAK,EAAL,EgBZkB,E,EAAS,CAAT,CAAzB,ElBnBO,E,sDkByBW,E,KAAc,E,KhBMG,E,EgBNH,G,EhBMyB,CAAlD,EAAK,EAAL,EgBNW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBAxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBAmC,CAAzB,CAAzB,ElB1BO,E,sDkBgCW,E,KAAc,E,KhBDG,E,EgBCH,G,EhBDyB,CAAlD,EAAK,EAAL,EgBCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAyB,EhBPxB,G,EAKoB,E,EAAsB,CAAlD,EAAK,EAAL,E,EALQ,G,EgBOoC,CAA1B,CAAzB,ElBjCO,E,sDkBuCW,E,YhBRiB,E,EgBQH,G,EhBRyB,CAAlD,EAAK,EAAL,EgBQW,E,GAAJ,CAAd,E,EAC4B,E,KhBdb,GgBcf,E,EACA,E,KAAc,E,KhBVqB,E,EgBUrB,G,EhBV2C,CAAlD,EAAK,EAAL,EgBUoC,E,EAAS,C,CAAb,CAAvC,ElBzCO,E,wDkB+CW,E,KAAc,E,KhBhBG,E,EgBgBH,G,EhBhByB,CAAlD,EAAK,EAAL,EgBgBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBjBG,E,EgBiBH,G,EhBjByB,CAAlD,EAAK,EAAL,E,EgBiBO,CAAd,E,EACA,E,KAAc,E,KhBlBqB,E,EgBkBrB,G,EhBlB2C,CAAlD,EAAK,EAAL,EgBkBgC,EAAS,EAAT,ChBvBhC,CgBuBP,ElBjDO,E,wDkBuDW,E,KAAc,E,KhBxBG,E,EgBwBH,G,EhBxByB,CAAlD,EAAK,EAAL,EgBwBW,E,GAAJ,CAAd,E,EACkB,E,KAAc,E,KhBzBG,E,EgByBH,G,EhBzByB,CAAlD,EAAK,EAAL,E,EgByBO,CAAd,E,EACA,E,KAAc,E,KhB1BqB,E,EgB0BrB,G,EhB1B2C,CAAlD,EAAK,EAAL,EgB0BgC,EAAU,EAAV,ChB/BhC,CgB+BP,ElBzDO,E,sDkB+DW,E,KAAc,E,KhBhCG,E,EgBgCH,G,EhBhCyB,CAAlD,EAAK,EAAL,EgBgCW,E,GAAJ,CAAd,E,EACmC,E,KAAc,E,KhBjCd,E,EgBiCc,G,EhBjCQ,CAAlD,EAAK,EAAL,E,EgBiCwB,CAA/B,E,EACA,E,KAAc,E,KhBlCqB,E,EgBkCrB,G,EhBlC2C,CAAlD,EAAK,EAAL,EgBkCoC,E,EAAY,C,CAAhB,CAAvC,ElBjEO,E,6DkBuEW,E,KAAc,E,KhBxCG,E,EgBwCH,G,EhBxCyB,CAAlD,EAAK,EAAL,EgBwCW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBzCJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgByCI,G,EhBzCkB,CAAlD,EAAK,EAAL,EgByCkB,E,EAA0B,CAA1B,CAAzB,ElBxEO,E,6DkB8EW,E,KAAc,E,KhB/CG,E,EgB+CH,G,EhB/CyB,CAAlD,EAAK,EAAL,EgB+CW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAW,E,KAAc,E,KhBhDJ,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBgDI,G,EhBhDkB,CAAlD,EAAK,EAAL,EgBgDkB,E,EAA2B,CAA3B,CAAzB,ElB/EO,E,6DkBqFW,E,KAAc,E,KhBtDG,E,EgBsDH,G,EhBtDyB,CAAlD,EAAK,EAAL,EgBsDW,E,GAAJ,CAAd,E,EACA,E,KAAc,E,KAAA,G,IAAe,E,KAAc,E,KhBvDR,E,EAAsB,CAAlD,EAAK,EAAL,E,EAA4B,E,EgBuDQ,G,EhBvDc,CAAlD,EAAK,EAAL,EgBuDkB,E,EAA+B,CAA/B,CAAzB,ElBtFO,E,mDV8HkB,E,GAAnB,E,KAAA,CAAJ,EAA6D,G,cACnD,E,GAAiB,E,KAAjB,CAA+B,EAAzC,G,2DQ4EY,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,E,IAAf,G,EACO,E,kEqB9PO,E,QAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,2DrBgQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAEF,E,iBAAU,EAAK,EAAQ,GAAR,CAAf,G,EACI,E,iBAAA,EAAmB,EAAnB,CAAJ,E,EACE,E,iBAAU,EAAK,E,KAAS,EAAT,CAAf,I,EAEA,E,iBAAW,EAAK,E,KAAS,EAAT,CAAhB,I,EAEK,E,kEqBrQO,E,QAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DrBuQO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,EAAK,EAAI,GAAJ,CAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,EAAK,EAAI,GAAJ,CAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEqBpRO,E,QAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DrBsRO,E,OAAe,EAAc,EAAS,EAAtC,E,OACR,E,oBAAJ,E,EACS,E,eAAP,E,EAIU,E,iBAAA,EAAZ,E,EAEgB,EAAI,EAAJ,C,IACd,E,iBAAU,E,EAAK,C,IAAf,GACI,EAAK,EAAL,CAAJ,EAFuB,E,GAAA,E,IAKZ,EAAR,E,IAAe,E,iBAAA,EAAJ,G,IACd,E,iBAAW,E,EAAK,C,IAAhB,GACI,EAAK,EAAL,CAAJ,EAFqC,E,GAAA,E,MAKhC,E,kEqBnSO,E,QAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBkDjB,GiBlDG,G,OACD,E,KAAV,E,+DAKO,E,KAAa,E,YAAa,E,KAAc,E,WjBiDnB,E,EiBjDmB,G,EjBiDG,CAAlD,EAAK,EAAL,EiBjDiC,EAAyB,G,CAA9B,CAArB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAc,E,KAAc,E,WjB2CrB,E,EiB3CqB,G,EjB2CC,CAAlD,EAAK,EAAL,EiB3CmC,EAAyB,I,CAA/B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAY,E,KAAc,E,WjBqCnB,E,EiBrCmB,G,EjBqCG,CAAlD,EAAK,EAAL,E,EiBrC6B,CAAtB,G,OACG,E,KAAV,E,+DAKO,E,KAAc,E,YAAQ,E,KAAc,E,WjB+Bf,E,EiB/Be,G,EjB+BO,CAAlD,EAAK,EAAL,EiB/B6B,EAAtB,G,OACG,E,KAAV,E,6DAKa,E,YjByBe,E,EiBzBD,G,EjByBuB,CAAlD,EAAK,EAAL,EiBzBa,E,EAAuC,EjBoB5C,G,EAAA,G,CiBpBC,CAAhB,E,EACkB,E,KAA2B,E,OAAd,E,KAAuB,GAAd,CAAtB,G,OACD,E,KAAV,E,6DAKa,E,YjBkBe,E,EiBlBD,G,EjBkBuB,CAAlD,EAAK,EAAL,EiBlBa,E,EAAuC,EjBa5C,G,EAAA,G,CiBbC,CAAhB,E,EACkB,E,KAA6B,E,OAAf,E,KAAwB,IAAf,CAAvB,G,OACD,E,KAAV,E,6DAKa,E,YjBWe,E,EiBXD,G,EjBWuB,CAAlD,EAAK,EAAL,EiBXa,E,EAAuC,EjBM5C,G,EAAA,G,CiBNC,CAAhB,E,EACkB,E,KAAuB,E,OAAT,E,KAAd,G,OACD,E,KAAV,E,6DAKa,E,YjBIe,E,EiBJD,G,EjBIuB,CAAlD,EAAK,EAAL,EiBJa,E,EAAuC,EjBD5C,G,EAAA,G,CiBCC,CAAhB,E,EACkB,E,KAAqC,E,OAAvB,E,EjBFjB,GiBEG,G,OACD,E,KAAV,E,+DAKa,E,YjBHe,E,EiBGD,G,EjBHuB,CAAlD,EAAK,EAAL,EiBGa,E,EAAuC,EjBR5C,G,EAAA,G,CiBQC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA5B,E,EjBJQ,E,EiBIoB,G,EjBJE,CAAlD,EAAK,EAAL,EiBIkC,EAAyB,G,CAA9B,CAAtB,G,OACG,E,KAAV,E,+DAKa,E,YjBVe,E,EiBUD,G,EjBVuB,CAAlD,EAAK,EAAL,EiBUa,E,EAAuC,EjBf5C,G,EAAA,G,CiBeC,CAAhB,E,EACc,E,KAA6B,E,KAAc,E,OAA7B,E,EjBXO,E,EiBWsB,G,EjBXA,CAAlD,EAAK,EAAL,EiBWoC,EAAyB,I,CAA/B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBjBe,E,EiBiBD,G,EjBjBuB,CAAlD,EAAK,EAAL,EiBiBa,E,EAAuC,EjBtB5C,G,EAAA,G,CiBsBC,CAAhB,E,EACc,E,KAA2B,E,KAAc,E,OAA3B,E,EjBlBO,E,EiBkBoB,G,EjBlBE,CAAlD,EAAK,EAAL,E,EiBkB8B,CAAvB,G,OACG,E,KAAV,E,+DAKa,E,YjBxBe,E,EiBwBD,G,EjBxBuB,CAAlD,E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E,KAOmC,G,EANnC,EAMwC,G,EAAA,G,aAArB,G,wD2B5KI,E,KAAN,E,EAAY,EAA5B,G,KACT,GAAJ,E,OACS,EAAP,E,yEAfO,E,YACA,E,YACA,E,YACA,E,UACO,E,sCAehB,E,KAAmB,E,gCAEX,E,mBAOJ,E,KAA2B,E,OpB5MhB,G,QoBmNX,E,KAAa,E,KAAc,E,OpB9MI,E,EoB8MJ,G,EpB9M0B,CAAlD,EAAK,EAAL,EoB8MU,E,QAIb,E,KAAa,E,KAAc,E,OpBlNI,E,EoBkNJ,G,EpBlN0B,CAAlD,EAAK,EAAL,EoBkNU,E,KACb,E,KAAkB,E,KAAJ,GAAe,EAAf,C,IAAyB,EAAJ,G,EAArB,E,EAAqB,GAAtB,C,QAab,E,KAAa,E,KAAc,E,OpBhOI,E,EoBgOJ,G,EpBhO0B,CAAlD,EAAK,EAAL,EoBgOU,E,KACb,E,KAAa,E,KAAc,E,OpBjOI,E,EoBiOJ,G,EpBjO0B,CAAlD,EAAK,EAAL,EoBiOU,E,QAab,E,KAAa,E,KAAc,E,OpB9OI,E,EoB8OJ,G,EpB9O0B,CAAlD,EAAK,EAAL,EoB8OU,E,KACb,E,KAAa,E,KAAc,E,OpB/OI,E,EoB+OJ,G,EpB/O0B,CAAlD,EAAK,EAAL,EoB+OU,E,KACb,E,KAA2B,E,OpBrPhB,G,KoBsPX,E,KAA2B,E,OpBtPhB,G,QoByPX,E,KAAa,E,KAAc,E,OpBpPI,E,EoBoPJ,G,EpBpP0B,CAAlD,EAAK,EAAL,EoBoPU,E,KACb,E,KAAa,E,KAAc,E,OpBrPI,E,EoBqPJ,G,EpBrP0B,CAAlD,EAAK,EAAL,EoBqPU,E,KACb,E,KAAa,E,KAAc,E,OpBtPI,E,EoBsPJ,G,EpBtP0B,CAAlD,EAAK,EAAL,EoBsPU,E,eAGgC,E,iBAA7B,G,+BArDhB,E,KAA2B,E,OpBzMhB,G,QoB6MX,E,KAA2B,E,OpB7MhB,G,QoB2NX,E,KAAa,E,KAAc,E,OpBtNI,E,EoBsNJ,G,EpBtN0B,CAAlD,EAAK,EAAL,EoBsNU,E,KACb,E,KAA2B,E,OpB5NhB,G,QoByOX,E,KAAa,E,KAAc,E,OpBpOI,E,EoBoOJ,G,EpBpO0B,CAAlD,EAAK,EAAL,EoBoOU,E,KACb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","sourceRoot":"./release","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { GasCounter, gasCounter } from \"./gas\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION, SBRK } from \"./instructions\";\nimport { Outcome, Result } from \"./instructions/outcome\";\nimport { reg } from \"./instructions/utils\";\nimport { RUN } from \"./instructions-exe\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY } from \"./memory-page\";\nimport { BasicBlocks, decodeArguments, JumpTable, Program, ProgramCounter } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport enum Status {\n OK = -1,\n HALT = 0,\n PANIC = 1,\n FAULT = 2,\n HOST = 3,\n OOG = 4,\n}\n\nexport class Interpreter {\n public readonly program: Program;\n public readonly registers: Registers;\n public readonly memory: Memory;\n public readonly gas: GasCounter;\n // TODO [ToDr] consider making this just getters?\n public pc: u32;\n public status: Status;\n public exitCode: u32;\n public nextPc: u32;\n public useSbrkGas: boolean;\n\n constructor(program: Program, registers: Registers, memory: Memory = new MemoryBuilder().build(0)) {\n this.program = program;\n this.registers = registers;\n this.memory = memory;\n this.gas = gasCounter(0);\n this.pc = 0;\n this.status = Status.OK;\n this.exitCode = -1;\n this.nextPc = 0;\n this.useSbrkGas = false;\n }\n\n nextStep(): boolean {\n // resuming after host call\n if (this.status === Status.HOST) {\n // let's assume all is good and move on :)\n this.status = Status.OK;\n // apply the nextPc, but don't stop, rather continue\n // executing right away.\n this.pc = this.nextPc;\n this.nextPc = -1;\n this.exitCode = -1;\n }\n\n if (this.status !== Status.OK) {\n return false;\n }\n\n // TODO [ToDr] Some weird pre-init step for the debugger?\n if (this.nextPc !== -1) {\n this.pc = this.nextPc;\n this.nextPc = -1;\n return true;\n }\n\n const pc = this.pc;\n // check if we are at the right location\n if (!this.program.mask.isInstruction(pc)) {\n // TODO [ToDr] Potential edge case here?\n if (this.gas.sub(MISSING_INSTRUCTION.gas)) {\n this.status = Status.OOG;\n } else {\n this.status = Status.PANIC;\n }\n return false;\n }\n\n const instruction = this.program.code[pc];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n\n // check gas (might be done for each block instead).\n if (this.gas.sub(iData.gas)) {\n this.status = Status.OOG;\n return false;\n }\n\n if (iData === MISSING_INSTRUCTION) {\n this.status = Status.PANIC;\n return false;\n }\n\n // get args and invoke instruction\n const skipBytes = this.program.mask.skipBytesToNextInstruction(pc);\n const args = decodeArguments(iData.kind, this.program.code.subarray(pc + 1), skipBytes);\n\n // additional gas cost of sbrk\n if (iData === SBRK && this.useSbrkGas) {\n const alloc = u64(u32(this.registers[reg(args.a)]));\n const gas = ((alloc + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) * 16;\n if (this.gas.sub(gas)) {\n this.status = Status.OOG;\n return false;\n }\n }\n\n const exe = RUN[instruction];\n const outcome = exe(args, this.registers, this.memory);\n\n // TODO [ToDr] Spaghetti\n switch (outcome.outcome) {\n case Outcome.DynamicJump: {\n const res = dJump(this.program.jumpTable, outcome.dJump);\n if (res.status === DjumpStatus.HALT) {\n this.status = Status.HALT;\n return true;\n }\n if (res.status === DjumpStatus.PANIC) {\n this.status = Status.PANIC;\n return false;\n }\n const branchResult = branch(this.program.basicBlocks, res.newPc, 0);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.StaticJump: {\n const branchResult = branch(this.program.basicBlocks, pc, outcome.staticJump);\n if (!branchResult.isOkay) {\n this.status = Status.PANIC;\n return false;\n }\n\n this.pc = branchResult.newPc;\n return true;\n }\n case Outcome.Result: {\n if (outcome.result === Result.HOST) {\n this.status = Status.HOST;\n this.exitCode = outcome.exitCode;\n // set the next PC after the host call is called.\n this.nextPc = this.pc + 1 + skipBytes;\n return false;\n }\n if (outcome.result === Result.FAULT) {\n this.gas.sub(1);\n // access to reserved memory should end with a panic.\n if (outcome.exitCode < RESERVED_MEMORY) {\n this.status = Status.PANIC;\n } else {\n this.status = Status.FAULT;\n this.exitCode = outcome.exitCode;\n }\n return false;\n }\n if (outcome.result === Result.FAULT_ACCESS) {\n this.gas.sub(1);\n this.status = Status.PANIC;\n // this.exitCode = outcome.exitCode;\n return false;\n }\n if (outcome.result === Result.PANIC) {\n this.status = Status.PANIC;\n this.exitCode = outcome.exitCode;\n return false;\n }\n\n throw new Error(\"Unknown result\");\n }\n case Outcome.Ok: {\n // by default move to next instruction.\n this.pc += 1 + skipBytes;\n return true;\n }\n }\n\n return false;\n }\n}\n\n// @unmanaged\nclass BranchResult {\n isOkay: boolean = false;\n newPc: u32 = 0;\n}\n\nfunction branch(basicBlocks: BasicBlocks, pc: u32, offset: i32): BranchResult {\n const r = new BranchResult();\n const newPc = pc + offset;\n if (basicBlocks.isStart(newPc)) {\n r.isOkay = true;\n r.newPc = newPc;\n }\n return r;\n}\n\nenum DjumpStatus {\n OK = 0,\n HALT = 1,\n PANIC = 2,\n}\n\n// @unmanaged\nclass DjumpResult {\n status: DjumpStatus = DjumpStatus.OK;\n newPc: ProgramCounter = 0;\n}\n\nconst EXIT = 0xff_ff_00_00;\nconst JUMP_ALIGMENT_FACTOR = 2;\n\nfunction dJump(jumpTable: JumpTable, address: u32): DjumpResult {\n const r = new DjumpResult();\n if (address === EXIT) {\n r.status = DjumpStatus.HALT;\n return r;\n }\n if (address === 0 || address % JUMP_ALIGMENT_FACTOR !== 0) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const index = address / JUMP_ALIGMENT_FACTOR - 1;\n if (index >= jumpTable.jumps.length) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n const newPc: u64 = jumpTable.jumps[index];\n if (newPc >= MAX_U32) {\n r.status = DjumpStatus.PANIC;\n return r;\n }\n\n r.newPc = u32(newPc);\n return r;\n}\n\nconst MAX_U32: u64 = 2 ** 32;\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { buildMemory, InitialChunk, InitialPage } from \"./api-internal\";\nimport { Decoder } from \"./codec\";\nimport { Gas } from \"./gas\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE } from \"./memory-page\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, REG_SIZE_BYTES, Registers } from \"./registers\";\nimport { decodeSpi } from \"./spi\";\n\nlet interpreter: Interpreter | null = null;\n\nexport function resetJAM(program: u8[], pc: number, initialGas: Gas, args: u8[], hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = decodeSpi(code, liftBytes(args));\n const int = new Interpreter(p.program, p.registers, p.memory);\n int.nextPc = pc;\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGeneric(program: u8[], flatRegisters: u8[], initialGas: Gas, hasMetadata: boolean = false): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n const int = new Interpreter(p, registers);\n int.gas.set(initialGas);\n\n if (interpreter !== null) {\n (interpreter).memory.free();\n }\n\n interpreter = int;\n}\n\nexport function resetGenericWithMemory(\n program: u8[],\n flatRegisters: u8[],\n pageMap: Uint8Array,\n chunks: Uint8Array,\n initialGas: Gas,\n hasMetadata: boolean = false,\n): void {\n const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);\n\n const p = deblob(code);\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n fillRegisters(registers, flatRegisters);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, readPages(pageMap), readChunks(chunks));\n\n const int = new Interpreter(p, registers, memory);\n int.gas.set(initialGas);\n\n interpreter = int;\n}\n\nexport function nextStep(): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n return int.nextStep();\n }\n return false;\n}\n\nexport function nSteps(steps: u32): boolean {\n if (interpreter !== null) {\n const int = interpreter;\n let isOk = true;\n for (let i: u32 = 0; i < steps; i++) {\n isOk = int.nextStep();\n if (!isOk) {\n return false;\n }\n }\n return isOk;\n }\n return false;\n}\n\nexport function getProgramCounter(): u32 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return u32(int.pc);\n}\n\nexport function setNextProgramCounter(pc: u32): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.nextPc = pc;\n}\n\nexport function getStatus(): u8 {\n if (interpreter === null) {\n return Status.PANIC;\n }\n const int = interpreter;\n return int.status;\n}\n\nexport function getExitArg(): i32 {\n if (interpreter === null) {\n return -1;\n }\n const int = interpreter;\n return int.exitCode || -1;\n}\n\nexport function getGasLeft(): i64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.gas.get();\n}\n\nexport function setGasLeft(gas: i64): void {\n if (interpreter !== null) {\n const int = interpreter;\n int.gas.set(gas);\n }\n}\n\nexport function getRegister(reg: u8): u64 {\n if (interpreter === null) {\n return 0;\n }\n const int = interpreter;\n return int.registers[reg];\n}\n\nexport function setRegister(reg: u8, value: u64): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n int.registers[reg] = value;\n}\n\nexport function getRegisters(): Uint8Array {\n const flat = new Uint8Array(NO_OF_REGISTERS * REG_SIZE_BYTES).fill(0);\n if (interpreter === null) {\n return flat;\n }\n\n const int = interpreter;\n for (let i = 0; i < int.registers.length; i++) {\n let val = int.registers[i];\n for (let j = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n flat[index] = (val & 0xff);\n val = val >> 8;\n }\n }\n\n return flat;\n}\n\nexport function setRegisters(flatRegisters: u8[]): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n fillRegisters(int.registers, flatRegisters);\n}\n\nexport function getPageDump(index: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n const int = interpreter;\n const page = int.memory.pageDump(index);\n if (page === null) {\n return new Uint8Array(PAGE_SIZE).fill(0);\n }\n\n return page;\n}\n\nexport function getMemory(address: u32, length: u32): Uint8Array {\n if (interpreter === null) {\n return new Uint8Array(0);\n }\n const int = interpreter;\n const result = new Uint8Array(length);\n const fault = int.memory.bytesRead(address, result);\n if (fault.isFault) {\n return new Uint8Array(0);\n }\n return result;\n}\n\nexport function setMemory(address: u32, data: Uint8Array): void {\n if (interpreter === null) {\n return;\n }\n const int = interpreter;\n const end = address + data.length;\n for (let i = address; i < end; i++) {\n // TODO [ToDr] handle page fault?\n int.memory.setU8(i, data[i - address]);\n }\n}\n\nfunction fillRegisters(registers: Registers, flat: u8[]): void {\n const len = registers.length * REG_SIZE_BYTES;\n if (len !== flat.length) {\n throw new Error(`Mismatching registers size, got: ${flat.length}, expected: ${len}`);\n }\n\n for (let i = 0; i < registers.length; i++) {\n let num: u64 = 0;\n for (let j: u8 = 0; j < REG_SIZE_BYTES; j++) {\n const index = i * REG_SIZE_BYTES + j;\n num |= (flat[index]) << (j * 8);\n }\n registers[i] = num;\n }\n}\n\nfunction readPages(pageMap: Uint8Array): InitialPage[] {\n const pages: InitialPage[] = [];\n const codec = new Decoder(pageMap);\n while (!codec.isExhausted()) {\n const p = new InitialPage();\n p.address = codec.u32();\n p.length = codec.u32();\n p.access = codec.u8() > 0 ? Access.Write : Access.Read;\n pages.push(p);\n }\n return pages;\n}\n\nfunction readChunks(chunks: Uint8Array): InitialChunk[] {\n const res: InitialChunk[] = [];\n const codec = new Decoder(chunks);\n while (!codec.isExhausted()) {\n const c = new InitialChunk();\n c.address = codec.u32();\n const len = codec.u32();\n const data = codec.bytes(len);\n for (let i: u32 = 0; i < len; i++) {\n c.data.push(data[i]);\n }\n res.push(c);\n }\n return res;\n}\n","import { buildMemory, getAssembly, InitialChunk, InitialPage, runVm, VmInput, VmOutput } from \"./api-internal\";\nimport { BlockGasCost, computeGasCosts } from \"./gas-costs\";\nimport { MemoryBuilder } from \"./memory\";\nimport { deblob, extractCodeAndMetadata, liftBytes } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\nimport { decodeSpi, StandardProgram } from \"./spi\";\n\nexport enum InputKind {\n Generic = 0,\n SPI = 1,\n}\n\nexport enum HasMetadata {\n Yes = 0,\n No = 1,\n}\n\nexport function getGasCosts(input: u8[], kind: InputKind, withMetadata: HasMetadata): BlockGasCost[] {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n return computeGasCosts(program.program).values();\n}\n\nexport function disassemble(input: u8[], kind: InputKind, withMetadata: HasMetadata): string {\n const program = prepareProgram(kind, withMetadata, input, [], [], [], []);\n\n let output = \"\";\n if (withMetadata === HasMetadata.Yes) {\n output = \"Metadata: \\n\";\n output += \"0x\";\n output += program.metadata.reduce((acc, x) => acc + x.toString(16).padStart(2, \"0\"), \"\");\n output += \"\\n\\n\";\n }\n\n output += getAssembly(program.program);\n\n return output;\n}\n\nexport function prepareProgram(\n kind: InputKind,\n hasMetadata: HasMetadata,\n program: u8[],\n initialRegisters: u64[],\n initialPageMap: InitialPage[],\n initialMemory: InitialChunk[],\n args: u8[],\n): StandardProgram {\n let code = liftBytes(program);\n let metadata = new Uint8Array(0);\n\n if (hasMetadata === HasMetadata.Yes) {\n const data = extractCodeAndMetadata(code);\n code = data.code;\n metadata = data.metadata;\n }\n\n if (kind === InputKind.Generic) {\n const program = deblob(code);\n\n const builder = new MemoryBuilder();\n const memory = buildMemory(builder, initialPageMap, initialMemory);\n\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n for (let r = 0; r < initialRegisters.length; r++) {\n registers[r] = initialRegisters[r];\n }\n\n const exe: StandardProgram = new StandardProgram(program, memory, registers);\n exe.metadata = metadata;\n\n return exe;\n }\n\n if (kind === InputKind.SPI) {\n const exe = decodeSpi(code, liftBytes(args));\n exe.metadata = metadata;\n return exe;\n }\n\n throw new Error(`Unknown kind: ${kind}`);\n}\n\nexport function runProgram(\n program: StandardProgram,\n initialGas: i64 = 0,\n programCounter: u32 = 0,\n logs: boolean = false,\n useSbrkGas: boolean = false,\n): VmOutput {\n const vmInput = new VmInput(program.program, program.memory, program.registers);\n vmInput.gas = initialGas;\n vmInput.pc = programCounter;\n\n return runVm(vmInput, logs, useSbrkGas);\n}\n","import { RELEVANT_ARGS } from \"./arguments\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Interpreter, Status } from \"./interpreter\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, RESERVED_MEMORY } from \"./memory-page\";\nimport { decodeArguments, Program, resolveArguments } from \"./program\";\nimport { Registers } from \"./registers\";\n\nexport class InitialPage {\n address: u32 = 0;\n length: u32 = 0;\n access: Access = Access.None;\n}\nexport class InitialChunk {\n address: u32 = 0;\n data: u8[] = [];\n}\n\nexport class VmInput {\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n}\n\nexport class VmOutput {\n status: Status = Status.OK;\n registers: u64[] = [];\n pc: u32 = 0;\n memory: InitialChunk[] = [];\n gas: i64 = 0;\n exitCode: u32 = 0;\n}\n\nexport function getAssembly(p: Program): string {\n const len = p.code.length;\n if (len === 0) {\n return \"\";\n }\n\n let v = \"\";\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n v += \"\\n\";\n v += `${i}: `;\n v += changetype(iData.namePtr);\n v += `(${instruction})`;\n\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n const args = decodeArguments(iData.kind, p.code.subarray(i + 1), skipBytes);\n const argsArray = [args.a, args.b, args.c, args.d];\n const relevantArgs = RELEVANT_ARGS[iData.kind];\n for (let i = 0; i < relevantArgs; i++) {\n v += ` ${argsArray[i]}, `;\n }\n i += skipBytes;\n }\n return v;\n}\n\nexport function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean = false): VmOutput {\n const int = new Interpreter(input.program, input.registers, input.memory);\n int.useSbrkGas = useSbrkGas;\n int.nextPc = input.pc;\n int.gas.set(input.gas);\n\n return executeProgram(int, logs);\n}\n\nexport function getOutputChunks(memory: Memory): InitialChunk[] {\n const chunks: InitialChunk[] = [];\n const pages = memory.pages.keys();\n let currentChunk: InitialChunk | null = null;\n for (let i = 0; i < pages.length; i++) {\n const pageIdx = pages[i];\n const page = memory.pages.get(pageIdx);\n\n // skip empty pages\n if (page.raw.page === null) {\n continue;\n }\n\n for (let n = 0; n < page.raw.data.length; n++) {\n const v = page.raw.data[n];\n if (v !== 0) {\n if (currentChunk !== null) {\n currentChunk.data.push(v);\n } else {\n currentChunk = new InitialChunk();\n currentChunk.address = pageIdx * PAGE_SIZE + n;\n currentChunk.data = [v];\n }\n } else if (currentChunk !== null) {\n chunks.push(currentChunk);\n currentChunk = null;\n }\n }\n }\n if (currentChunk !== null) {\n chunks.push(currentChunk);\n }\n return chunks;\n}\n\nexport function buildMemory(builder: MemoryBuilder, pages: InitialPage[], chunks: InitialChunk[]): Memory {\n let sbrkIndex = RESERVED_MEMORY;\n\n for (let i = 0; i < pages.length; i++) {\n const initPage = pages[i];\n builder.setData(initPage.access, initPage.address, new Uint8Array(initPage.length));\n // find the highest writeable page and set the sbrk index there.\n if (initPage.access === Access.Write) {\n sbrkIndex = initPage.address < sbrkIndex ? sbrkIndex : initPage.address;\n }\n }\n\n for (let i = 0; i < chunks.length; i++) {\n const initChunk = chunks[i];\n // access should not matter now, since we created the pages already.\n const data = new Uint8Array(initChunk.data.length);\n for (let i = 0; i < data.length; i++) {\n data[i] = initChunk.data[i];\n }\n builder.setData(Access.None, initChunk.address, data);\n }\n\n return builder.build(sbrkIndex);\n}\n\nfunction executeProgram(int: Interpreter, logs: boolean = false): VmOutput {\n let isOk = true;\n for (;;) {\n if (!isOk) {\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")} (final)`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")} (final)`);\n if (logs) console.log(`Finished with status: ${int.status}`);\n if (logs) console.log(`Exit code: ${int.exitCode}`);\n break;\n }\n\n if (logs) console.log(`PC = ${int.pc}`);\n if (logs) console.log(`GAS = ${int.gas.get()}`);\n if (logs) console.log(`STATUS = ${int.status}`);\n if (logs) console.log(`REGISTERS = ${int.registers.join(\", \")}`);\n if (logs) console.log(`REGISTERS = ${int.registers.map((x: u64) => `0x${x.toString(16)}`).join(\", \")}`);\n if (logs) {\n const instruction = int.pc < u32(int.program.code.length) ? int.program.code[int.pc] : 0;\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n const skipBytes = int.program.mask.skipBytesToNextInstruction(int.pc);\n const name = changetype(iData.namePtr);\n console.log(`INSTRUCTION = ${name} (${instruction})`);\n const args = resolveArguments(iData.kind, int.program.code.subarray(int.pc + 1), skipBytes, int.registers);\n if (args !== null) {\n console.log(`ARGUMENTS:\n ${args.a} (${args.decoded.a}) = 0x${u64(args.a).toString(16)}, \n ${args.b} (${args.decoded.b}) = 0x${u64(args.b).toString(16)},\n ${args.c} (${args.decoded.c}) = 0x${u64(args.c).toString(16)},\n ${args.d} (${args.decoded.d}) = 0x${u64(args.d).toString(16)}`);\n }\n }\n\n isOk = int.nextStep();\n }\n\n const output = new VmOutput();\n output.status = int.status;\n output.registers = int.registers.slice(0);\n output.pc = int.pc;\n output.gas = int.gas.get();\n output.memory = getOutputChunks(int.memory);\n output.exitCode = int.exitCode;\n\n return output;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","import { Arguments, nibbles, REQUIRED_BYTES } from \"./arguments\";\nimport { encodeVarU32 } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\n\n/** Turn given bytecode into a valid program. Add JumpTable and Mask. */\nexport function wrapAsProgram(bytecode: Uint8Array): Uint8Array {\n const jumpTableLength: u8 = 0;\n const jumpTableItemLength: u8 = 0;\n const codeLength = bytecode.length;\n const mask = buildMask(bytecode);\n const codeLengthBytes = encodeVarU32(codeLength);\n\n const data = new Uint8Array(1 + 1 + codeLengthBytes.length + codeLength + mask.length);\n data[0] = jumpTableLength;\n data[1] = jumpTableItemLength;\n let offset = 2;\n for (let i = 0; i < codeLengthBytes.length; i++) {\n data[offset] = codeLengthBytes[i];\n offset++;\n }\n for (let i = 0; i < bytecode.length; i++) {\n data[offset] = bytecode[i];\n offset++;\n }\n for (let i = 0; i < mask.length; i++) {\n data[offset] = mask[i];\n offset++;\n }\n return data;\n}\n\nfunction skipBytes(kind: Arguments, data: Uint8Array): i32 {\n switch (kind) {\n case Arguments.Zero:\n return 0;\n case Arguments.OneImm:\n return immBytes(data.length, 0);\n case Arguments.TwoImm: {\n const n = nibbles(data[0]);\n const split = n.low + 1;\n return 1 + split + immBytes(data.length, split + 1);\n }\n case Arguments.OneOff:\n return immBytes(data.length, 0);\n case Arguments.OneRegOneImm:\n return 1 + immBytes(data.length, 1);\n case Arguments.OneRegOneExtImm:\n return 9;\n case Arguments.OneRegTwoImm: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.OneRegOneImmOneOff: {\n const n = nibbles(data[0]);\n const split = n.hig + 1;\n return 1 + split + immBytes(data.length, 1 + split);\n }\n case Arguments.TwoReg:\n return 1;\n case Arguments.TwoRegOneImm:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegOneOff:\n return 1 + i32(Math.min(4, data.length));\n case Arguments.TwoRegTwoImm: {\n const n = nibbles(data[1]);\n const split = n.low + 1;\n return 2 + split + immBytes(data.length, 2 + split);\n }\n case Arguments.ThreeReg:\n return 2;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n\nfunction buildMask(bytecode: Uint8Array): u8[] {\n const mask = new StaticArray(bytecode.length);\n for (let i = 0; i < bytecode.length; i++) {\n const instruction = bytecode[i];\n const iData = instruction < INSTRUCTIONS.length ? INSTRUCTIONS[instruction] : MISSING_INSTRUCTION;\n mask[i] = true;\n\n const requiredBytes = REQUIRED_BYTES[iData.kind];\n if (i + 1 + requiredBytes <= bytecode.length) {\n i += skipBytes(iData.kind, bytecode.subarray(i + 1));\n }\n }\n // pack mask\n const packed: u8[] = [];\n for (let i = 0; i < mask.length; i += 8) {\n let byte: u8 = 0;\n for (let j = i; j < i + 8; j++) {\n byte >>= 1;\n if (j < mask.length && mask[j]) {\n byte |= 0b1000_0000;\n }\n }\n packed.push(byte);\n }\n return packed;\n}\n\nfunction immBytes(dataLength: i32, required: i32): i32 {\n if (dataLength < required) {\n return 0;\n }\n return i32(Math.min(4, dataLength - required));\n}\n","import { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { ArrayBuffer } from \"./arraybuffer\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from \"./util/error\";\n\n// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte\n\nexport class DataView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n constructor(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n byteLength: i32 = buffer.byteLength\n ) {\n if (\n i32(byteLength > BLOCK_MAXSIZE) |\n i32(byteOffset + byteLength > buffer.byteLength)\n ) throw new RangeError(E_INVALIDLENGTH);\n this.buffer = buffer; // links\n let dataStart = changetype(buffer) + byteOffset;\n this.dataStart = dataStart;\n this.byteLength = byteLength;\n }\n\n getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n return littleEndian\n ? load(this.dataStart + byteOffset)\n : reinterpret(bswap(load(this.dataStart + byteOffset)));\n }\n\n getInt8(byteOffset: i32): i8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getInt16(byteOffset: i32, littleEndian: bool = false): i16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getInt32(byteOffset: i32, littleEndian: bool = false): i32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint8(byteOffset: i32): u8 {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + byteOffset);\n }\n\n getUint16(byteOffset: i32, littleEndian: bool = false): u16 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u16 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint32(byteOffset: i32, littleEndian: bool = false): u32 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: u32 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n if (littleEndian) store(this.dataStart + byteOffset, value);\n else store(this.dataStart + byteOffset, bswap(reinterpret(value)));\n }\n\n setInt8(byteOffset: i32, value: i8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint8(byteOffset: i32, value: u8): void {\n if (byteOffset >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, value);\n }\n\n setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n // Non-standard additions that make sense in WebAssembly, but won't work in JS:\n\n getInt64(byteOffset: i32, littleEndian: bool = false): i64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result: i64 = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n getUint64(byteOffset: i32, littleEndian: bool = false): u64 {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n let result = load(this.dataStart + byteOffset);\n return littleEndian ? result : bswap(result);\n }\n\n setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {\n if (\n (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)\n ) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + byteOffset, littleEndian ? value : bswap(value));\n }\n\n toString(): string {\n return \"[object DataView]\";\n }\n}\n","/** Gas type. */\nexport type Gas = i64;\n\n/** Create a new gas counter instance depending on the gas value. */\nexport function gasCounter(gas: i64): GasCounter {\n return new GasCounterU64(gas);\n}\n\n/** An abstraction over gas counter.\n *\n * It can be optimized to use numbers instead of bigint in case of small gas.\n */\nexport interface GasCounter {\n /** Return remaining gas. */\n get(): Gas;\n\n /** Overwite remaining gas. Prefer sub method instead. */\n set(g: Gas): void;\n\n /** Returns true if there was an underflow. */\n sub(g: Gas): boolean;\n}\n\nclass GasCounterU64 implements GasCounter {\n constructor(private gas: Gas) {}\n\n set(g: Gas): void {\n this.gas = g;\n }\n\n get(): Gas {\n return this.gas;\n }\n\n sub(g: Gas): boolean {\n this.gas = this.gas - g;\n if (this.gas < 0) {\n this.gas = 0;\n return true;\n }\n return false;\n }\n}\n","import { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { Program } from \"./program\";\n\nexport class BlockGasCost {\n pc: u32 = 0;\n gas: u64 = 0;\n}\n\nexport function computeGasCosts(p: Program): Map {\n const len = p.code.length;\n const blocks: Map = new Map();\n let currentBlock: BlockGasCost | null = null;\n\n for (let i = 0; i < len; i++) {\n if (!p.mask.isInstruction(i)) {\n throw new Error(\"We should iterate only over instructions!\");\n }\n\n const instruction = p.code[i];\n const iData = instruction >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction];\n\n if (p.basicBlocks.isStart(i)) {\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n currentBlock = new BlockGasCost();\n currentBlock.pc = i;\n }\n\n if (currentBlock !== null) {\n // add gas for current instruction\n currentBlock.gas += iData.gas;\n }\n\n // move forward\n const skipBytes = p.mask.skipBytesToNextInstruction(i);\n i += skipBytes;\n }\n\n // add the final block\n if (currentBlock !== null) {\n blocks.set(currentBlock.pc, currentBlock);\n }\n\n return blocks;\n}\n","import { memcmp, memmove, memset } from \"./util/memory\";\nimport { E_NOTIMPLEMENTED } from \"./util/error\";\n\n/** Memory manager interface. */\nexport namespace memory {\n\n /** Gets the size of the memory in pages. */\n // @ts-ignore: decorator\n @builtin\n export declare function size(): i32;\n\n /** Grows the memory by the given size in pages and returns the previous size in pages. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function grow(pages: i32): i32;\n\n /** Fills a section in memory with the specified byte value. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function fill(dst: usize, c: u8, n: usize): void {\n memset(dst, c, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n /** Copies a section of memory to another. Has move semantics. */\n // @ts-ignore: decorator\n @unsafe @builtin\n export function copy(dst: usize, src: usize, n: usize): void {\n memmove(dst, src, n); // fallback if \"bulk-memory\" isn't enabled\n }\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;\n }\n\n /** Initializes a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Drops a memory segment. */\n // @ts-ignore: decorator\n @unsafe\n export function drop(segmentIndex: u32): void {\n throw new Error(E_NOTIMPLEMENTED);\n }\n\n /** Repeats a section of memory at a specific address. */\n // @ts-ignore: decorator\n @unsafe\n export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {\n let index: usize = 0;\n let total = srcLength * count;\n while (index < total) {\n memory.copy(dst + index, src, srcLength);\n index += srcLength;\n }\n }\n\n /** Compares a section of memory to another. */\n // @ts-ignore: decorator\n @inline\n export function compare(vl: usize, vr: usize, n: usize): i32 {\n return memcmp(vl, vr, n);\n }\n\n /** Gets a pointer to a static chunk of memory of the given size. */\n // @ts-ignore: decorator\n @builtin\n export declare function data(size: T, align?: i32): usize;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __data_end: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare let __stack_pointer: usize;\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __heap_base: usize;\n\n/** Heap memory interface. */\nexport namespace heap {\n\n /** Allocates a chunk of memory of at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function alloc(size: usize): usize {\n return __alloc(size);\n }\n\n /** Reallocates a chunk of memory to have at least the specified size. */\n // @ts-ignore: decorator\n @unsafe export function realloc(ptr: usize, size: usize): usize {\n return __realloc(ptr, size);\n }\n\n /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function free(ptr: usize): void {\n __free(ptr);\n }\n\n /** Dangerously resets the entire heap. Specific to the stub runtime. */\n // @ts-ignore: decorator\n @unsafe export function reset(): void {\n if (isDefined(__reset)) {\n __reset();\n } else {\n throw new Error(E_NOTIMPLEMENTED);\n }\n }\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/release.wat b/build/release.wat deleted file mode 100644 index 2560d97..0000000 --- a/build/release.wat +++ /dev/null @@ -1,38657 +0,0 @@ -(module - (type $0 (func (param i32 i32 i32) (result i32))) - (type $1 (func (param i32 i32) (result i32))) - (type $2 (func (param i32) (result i32))) - (type $3 (func (param i32))) - (type $4 (func (result i32))) - (type $5 (func (param i32 i32 i32))) - (type $6 (func (param i32 i32))) - (type $7 (func (param i32 i32 i32 i32) (result i32))) - (type $8 (func)) - (type $9 (func (param i32 i32 i32 i32))) - (type $10 (func (param i32 i32 i64))) - (type $11 (func (param i32 i64) (result i32))) - (type $12 (func (param i32 i64))) - (type $13 (func (param i32) (result i64))) - (type $14 (func (param i64) (result i32))) - (type $15 (func (param i32 i32 i32 i32 i64 i32))) - (type $16 (func (param i32 i32 i32 i32 i32 i32 i32) (result i32))) - (type $17 (func (param i64 i32 i32) (result i32))) - (type $18 (func (param i32 i64 i32 i32 i32) (result i32))) - (type $19 (func (param i32 i64 i32 i32))) - (type $20 (func (param i32 i64 i32))) - (type $21 (func (param i32 i32) (result i64))) - (type $22 (func (param i32 i32 i64) (result i32))) - (type $23 (func (result i64))) - (type $24 (func (param i64))) - (type $25 (func (param i64 i32) (result i32))) - (type $26 (func (param i32 f64 i64 i32 i32))) - (type $27 (func (param i32 i32 i64 i32))) - (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) - (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) - (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) - (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) - (global $~argumentsLength (mut i32) (i32.const 0)) - (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) - (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) - (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) - (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) - (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) - (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) - (global $assembly/api-debugger/interpreter (mut i32) (i32.const 0)) - (global $assembly/api-utils/InputKind.Generic i32 (i32.const 0)) - (global $assembly/api-utils/InputKind.SPI i32 (i32.const 1)) - (global $assembly/api-utils/HasMetadata.Yes i32 (i32.const 0)) - (global $assembly/api-utils/HasMetadata.No i32 (i32.const 1)) - (global $~lib/rt/__rtti_base i32 (i32.const 21552)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 54580)) - (memory $0 1) - (data $0 (i32.const 1036) "L") - (data $0.1 (i32.const 1048) "\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03") - (data $1 (i32.const 1116) ",") - (data $1.1 (i32.const 1128) "\04\00\00\00\10\00\00\00 \04\00\00 \04\00\004\00\00\00\r") - (data $2 (i32.const 1164) "L") - (data $2.1 (i32.const 1176) "\01\00\00\004") - (data $2.2 (i32.const 1192) "\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02") - (data $3 (i32.const 1244) ",") - (data $3.1 (i32.const 1256) "\04\00\00\00\10\00\00\00\a0\04\00\00\a0\04\00\004\00\00\00\r") - (data $4 (i32.const 1292) "<") - (data $4.1 (i32.const 1304) "\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e") - (data $5 (i32.const 1356) "<") - (data $5.1 (i32.const 1368) "\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s") - (data $8 (i32.const 1484) "<") - (data $8.1 (i32.const 1496) "\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e") - (data $9 (i32.const 1548) ",") - (data $9.1 (i32.const 1560) "\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s") - (data $11 (i32.const 1628) "<") - (data $11.1 (i32.const 1640) "\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s") - (data $12 (i32.const 1692) "\1c") - (data $12.1 (i32.const 1704) "\08\00\00\00\08\00\00\00\01") - (data $13 (i32.const 1724) "<") - (data $13.1 (i32.const 1736) "\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s") - (data $14 (i32.const 1788) "\1c") - (data $14.1 (i32.const 1800) "\08\00\00\00\08\00\00\00\02") - (data $15 (i32.const 1820) "\1c") - (data $15.1 (i32.const 1832) "\08\00\00\00\08\00\00\00\03") - (data $16 (i32.const 1852) "\1c") - (data $16.1 (i32.const 1864) "\08\00\00\00\08\00\00\00\04") - (data $17 (i32.const 1884) "\1c") - (data $17.1 (i32.const 1896) "\08\00\00\00\08\00\00\00\05") - (data $18 (i32.const 1916) "\1c") - (data $18.1 (i32.const 1928) "\08\00\00\00\08\00\00\00\06") - (data $19 (i32.const 1948) "\1c") - (data $19.1 (i32.const 1960) "\08\00\00\00\08\00\00\00\07") - (data $20 (i32.const 1980) "\1c") - (data $20.1 (i32.const 1992) "\08\00\00\00\08\00\00\00\08") - (data $21 (i32.const 2012) "\1c") - (data $21.1 (i32.const 2024) "\08\00\00\00\08\00\00\00\t") - (data $22 (i32.const 2044) "\1c") - (data $22.1 (i32.const 2056) "\08\00\00\00\08\00\00\00\n") - (data $23 (i32.const 2076) "\1c") - (data $23.1 (i32.const 2088) "\08\00\00\00\08\00\00\00\0b") - (data $24 (i32.const 2108) "\1c") - (data $24.1 (i32.const 2120) "\08\00\00\00\08\00\00\00\0c") - (data $25 (i32.const 2140) "\1c") - (data $25.1 (i32.const 2152) "\08\00\00\00\08\00\00\00\r") - (data $26 (i32.const 2172) "L") - (data $26.1 (i32.const 2184) "\01\00\00\004\00\00\00\b0\06\00\00\10\07\00\000\07\00\00P\07\00\00p\07\00\00\90\07\00\00\b0\07\00\00\d0\07\00\00\f0\07\00\00\10\08\00\000\08\00\00P\08\00\00p\08") - (data $27 (i32.const 2252) ",") - (data $27.1 (i32.const 2264) "\07\00\00\00\10\00\00\00\90\08\00\00\90\08\00\004\00\00\00\r") - (data $28 (i32.const 2300) ",") - (data $28.1 (i32.const 2312) "\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D") - (data $29 (i32.const 2348) "\1c") - (data $29.1 (i32.const 2360) "\02\00\00\00\08\00\00\00S\00B\00R\00K") - (data $30 (i32.const 2380) "\1c") - (data $30.1 (i32.const 2392) "\02\00\00\00\08\00\00\00T\00R\00A\00P") - (data $31 (i32.const 2412) ",") - (data $31.1 (i32.const 2424) "\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H") - (data $32 (i32.const 2460) "\1c") - (data $32.1 (i32.const 2472) "\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I") - (data $33 (i32.const 2492) ",") - (data $33.1 (i32.const 2504) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004") - (data $34 (i32.const 2540) ",") - (data $34.1 (i32.const 2552) "\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008") - (data $35 (i32.const 2588) ",") - (data $35.1 (i32.const 2600) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006") - (data $36 (i32.const 2636) ",") - (data $36.1 (i32.const 2648) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002") - (data $37 (i32.const 2684) ",") - (data $37.1 (i32.const 2696) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004") - (data $38 (i32.const 2732) "\1c") - (data $38.1 (i32.const 2744) "\02\00\00\00\08\00\00\00J\00U\00M\00P") - (data $39 (i32.const 2764) ",") - (data $39.1 (i32.const 2776) "\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D") - (data $40 (i32.const 2812) ",") - (data $40.1 (i32.const 2824) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M") - (data $41 (i32.const 2860) ",") - (data $41.1 (i32.const 2872) "\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008") - (data $42 (i32.const 2908) ",") - (data $42.1 (i32.const 2920) "\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008") - (data $43 (i32.const 2956) ",") - (data $43.1 (i32.const 2968) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006") - (data $44 (i32.const 3004) ",") - (data $44.1 (i32.const 3016) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006") - (data $45 (i32.const 3052) ",") - (data $45.1 (i32.const 3064) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002") - (data $46 (i32.const 3100) ",") - (data $46.1 (i32.const 3112) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002") - (data $47 (i32.const 3148) ",") - (data $47.1 (i32.const 3160) "\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004") - (data $48 (i32.const 3196) ",") - (data $48.1 (i32.const 3208) "\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008") - (data $49 (i32.const 3244) ",") - (data $49.1 (i32.const 3256) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006") - (data $50 (i32.const 3292) ",") - (data $50.1 (i32.const 3304) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002") - (data $51 (i32.const 3340) ",") - (data $51.1 (i32.const 3352) "\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004") - (data $52 (i32.const 3388) "<") - (data $52.1 (i32.const 3400) "\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008") - (data $53 (i32.const 3452) "<") - (data $53.1 (i32.const 3464) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006") - (data $54 (i32.const 3516) "<") - (data $54.1 (i32.const 3528) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002") - (data $55 (i32.const 3580) "<") - (data $55.1 (i32.const 3592) "\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004") - (data $56 (i32.const 3644) ",") - (data $56.1 (i32.const 3656) "\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P") - (data $57 (i32.const 3692) ",") - (data $57.1 (i32.const 3704) "\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M") - (data $58 (i32.const 3740) ",") - (data $58.1 (i32.const 3752) "\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M") - (data $59 (i32.const 3788) "<") - (data $59.1 (i32.const 3800) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M") - (data $60 (i32.const 3852) "<") - (data $60.1 (i32.const 3864) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M") - (data $61 (i32.const 3916) "<") - (data $61.1 (i32.const 3928) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M") - (data $62 (i32.const 3980) "<") - (data $62.1 (i32.const 3992) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M") - (data $63 (i32.const 4044) "<") - (data $63.1 (i32.const 4056) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M") - (data $64 (i32.const 4108) "<") - (data $64.1 (i32.const 4120) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M") - (data $65 (i32.const 4172) "<") - (data $65.1 (i32.const 4184) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M") - (data $66 (i32.const 4236) "<") - (data $66.1 (i32.const 4248) "\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M") - (data $67 (i32.const 4300) ",") - (data $67.1 (i32.const 4312) "\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G") - (data $68 (i32.const 4348) "<") - (data $68.1 (i32.const 4360) "\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004") - (data $69 (i32.const 4412) "<") - (data $69.1 (i32.const 4424) "\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002") - (data $70 (i32.const 4476) "<") - (data $70.1 (i32.const 4488) "\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004") - (data $71 (i32.const 4540) "<") - (data $71.1 (i32.const 4552) "\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002") - (data $72 (i32.const 4604) "<") - (data $72.1 (i32.const 4616) "\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004") - (data $73 (i32.const 4668) "<") - (data $73.1 (i32.const 4680) "\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002") - (data $74 (i32.const 4732) ",") - (data $74.1 (i32.const 4744) "\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008") - (data $75 (i32.const 4780) ",") - (data $75.1 (i32.const 4792) "\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006") - (data $76 (i32.const 4828) ",") - (data $76.1 (i32.const 4840) "\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006") - (data $77 (i32.const 4876) ",") - (data $77.1 (i32.const 4888) "\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S") - (data $78 (i32.const 4924) ",") - (data $78.1 (i32.const 4936) "\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008") - (data $79 (i32.const 4972) ",") - (data $79.1 (i32.const 4984) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006") - (data $80 (i32.const 5020) ",") - (data $80.1 (i32.const 5032) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002") - (data $81 (i32.const 5068) ",") - (data $81.1 (i32.const 5080) "\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004") - (data $82 (i32.const 5116) ",") - (data $82.1 (i32.const 5128) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008") - (data $83 (i32.const 5164) ",") - (data $83.1 (i32.const 5176) "\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008") - (data $84 (i32.const 5212) ",") - (data $84.1 (i32.const 5224) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006") - (data $85 (i32.const 5260) ",") - (data $85.1 (i32.const 5272) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006") - (data $86 (i32.const 5308) ",") - (data $86.1 (i32.const 5320) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002") - (data $87 (i32.const 5356) ",") - (data $87.1 (i32.const 5368) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002") - (data $88 (i32.const 5404) ",") - (data $88.1 (i32.const 5416) "\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004") - (data $89 (i32.const 5452) ",") - (data $89.1 (i32.const 5464) "\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002") - (data $90 (i32.const 5500) ",") - (data $90.1 (i32.const 5512) "\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M") - (data $91 (i32.const 5548) ",") - (data $91.1 (i32.const 5560) "\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M") - (data $92 (i32.const 5596) "\1c") - (data $92.1 (i32.const 5608) "\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M") - (data $93 (i32.const 5628) ",") - (data $93.1 (i32.const 5640) "\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002") - (data $94 (i32.const 5676) ",") - (data $94.1 (i32.const 5688) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M") - (data $95 (i32.const 5724) ",") - (data $95.1 (i32.const 5736) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M") - (data $96 (i32.const 5772) ",") - (data $96.1 (i32.const 5784) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002") - (data $97 (i32.const 5820) ",") - (data $97.1 (i32.const 5832) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002") - (data $98 (i32.const 5868) ",") - (data $98.1 (i32.const 5880) "\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002") - (data $99 (i32.const 5916) ",") - (data $99.1 (i32.const 5928) "\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002") - (data $100 (i32.const 5964) ",") - (data $100.1 (i32.const 5976) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M") - (data $101 (i32.const 6012) ",") - (data $101.1 (i32.const 6024) "\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M") - (data $102 (i32.const 6060) "<") - (data $102.1 (i32.const 6072) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") - (data $103 (i32.const 6124) "<") - (data $103.1 (i32.const 6136) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") - (data $104 (i32.const 6188) "<") - (data $104.1 (i32.const 6200) "\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002") - (data $105 (i32.const 6252) ",") - (data $105.1 (i32.const 6264) "\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M") - (data $106 (i32.const 6300) ",") - (data $106.1 (i32.const 6312) "\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M") - (data $107 (i32.const 6348) ",") - (data $107.1 (i32.const 6360) "\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004") - (data $108 (i32.const 6396) ",") - (data $108.1 (i32.const 6408) "\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004") - (data $109 (i32.const 6444) ",") - (data $109.1 (i32.const 6456) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004") - (data $110 (i32.const 6492) ",") - (data $110.1 (i32.const 6504) "\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004") - (data $111 (i32.const 6540) ",") - (data $111.1 (i32.const 6552) "\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004") - (data $112 (i32.const 6588) ",") - (data $112.1 (i32.const 6600) "\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004") - (data $113 (i32.const 6636) "<") - (data $113.1 (i32.const 6648) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") - (data $114 (i32.const 6700) "<") - (data $114.1 (i32.const 6712) "\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") - (data $115 (i32.const 6764) "<") - (data $115.1 (i32.const 6776) "\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004") - (data $116 (i32.const 6828) ",") - (data $116.1 (i32.const 6840) "\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M") - (data $117 (i32.const 6876) "<") - (data $117.1 (i32.const 6888) "\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T") - (data $118 (i32.const 6940) ",") - (data $118.1 (i32.const 6952) "\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M") - (data $119 (i32.const 6988) "<") - (data $119.1 (i32.const 7000) "\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T") - (data $120 (i32.const 7052) ",") - (data $120.1 (i32.const 7064) "\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q") - (data $121 (i32.const 7100) ",") - (data $121.1 (i32.const 7112) "\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E") - (data $122 (i32.const 7148) ",") - (data $122.1 (i32.const 7160) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U") - (data $123 (i32.const 7196) ",") - (data $123.1 (i32.const 7208) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S") - (data $124 (i32.const 7244) ",") - (data $124.1 (i32.const 7256) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U") - (data $125 (i32.const 7292) ",") - (data $125.1 (i32.const 7304) "\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S") - (data $126 (i32.const 7340) "<") - (data $126.1 (i32.const 7352) "\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D") - (data $127 (i32.const 7404) "\1c") - (data $127.1 (i32.const 7416) "\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002") - (data $128 (i32.const 7436) "\1c") - (data $128.1 (i32.const 7448) "\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002") - (data $129 (i32.const 7468) "\1c") - (data $129.1 (i32.const 7480) "\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002") - (data $130 (i32.const 7500) ",") - (data $130.1 (i32.const 7512) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002") - (data $131 (i32.const 7548) ",") - (data $131.1 (i32.const 7560) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002") - (data $132 (i32.const 7596) ",") - (data $132.1 (i32.const 7608) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002") - (data $133 (i32.const 7644) ",") - (data $133.1 (i32.const 7656) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002") - (data $134 (i32.const 7692) ",") - (data $134.1 (i32.const 7704) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002") - (data $135 (i32.const 7740) ",") - (data $135.1 (i32.const 7752) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002") - (data $136 (i32.const 7788) ",") - (data $136.1 (i32.const 7800) "\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002") - (data $137 (i32.const 7836) "\1c") - (data $137.1 (i32.const 7848) "\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004") - (data $138 (i32.const 7868) "\1c") - (data $138.1 (i32.const 7880) "\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004") - (data $139 (i32.const 7900) "\1c") - (data $139.1 (i32.const 7912) "\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004") - (data $140 (i32.const 7932) ",") - (data $140.1 (i32.const 7944) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004") - (data $141 (i32.const 7980) ",") - (data $141.1 (i32.const 7992) "\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004") - (data $142 (i32.const 8028) ",") - (data $142.1 (i32.const 8040) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004") - (data $143 (i32.const 8076) ",") - (data $143.1 (i32.const 8088) "\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004") - (data $144 (i32.const 8124) ",") - (data $144.1 (i32.const 8136) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004") - (data $145 (i32.const 8172) ",") - (data $145.1 (i32.const 8184) "\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004") - (data $146 (i32.const 8220) ",") - (data $146.1 (i32.const 8232) "\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004") - (data $147 (i32.const 8268) "\1c") - (data $147.1 (i32.const 8280) "\02\00\00\00\06\00\00\00A\00N\00D") - (data $148 (i32.const 8300) "\1c") - (data $148.1 (i32.const 8312) "\02\00\00\00\06\00\00\00X\00O\00R") - (data $149 (i32.const 8332) "\1c") - (data $149.1 (i32.const 8344) "\02\00\00\00\04\00\00\00O\00R") - (data $150 (i32.const 8364) ",") - (data $150.1 (i32.const 8376) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S") - (data $151 (i32.const 8412) ",") - (data $151.1 (i32.const 8424) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U") - (data $152 (i32.const 8460) ",") - (data $152.1 (i32.const 8472) "\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U") - (data $153 (i32.const 8508) ",") - (data $153.1 (i32.const 8520) "\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U") - (data $154 (i32.const 8556) ",") - (data $154.1 (i32.const 8568) "\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S") - (data $155 (i32.const 8604) ",") - (data $155.1 (i32.const 8616) "\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z") - (data $156 (i32.const 8652) ",") - (data $156.1 (i32.const 8664) "\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z") - (data $157 (i32.const 8700) ",") - (data $157.1 (i32.const 8712) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004") - (data $158 (i32.const 8748) ",") - (data $158.1 (i32.const 8760) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002") - (data $159 (i32.const 8796) ",") - (data $159.1 (i32.const 8808) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004") - (data $160 (i32.const 8844) ",") - (data $160.1 (i32.const 8856) "\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002") - (data $161 (i32.const 8892) ",") - (data $161.1 (i32.const 8904) "\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V") - (data $162 (i32.const 8940) "\1c") - (data $162.1 (i32.const 8952) "\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V") - (data $163 (i32.const 8972) "\1c") - (data $163.1 (i32.const 8984) "\02\00\00\00\08\00\00\00X\00N\00O\00R") - (data $164 (i32.const 9004) "\1c") - (data $164.1 (i32.const 9016) "\02\00\00\00\06\00\00\00M\00A\00X") - (data $165 (i32.const 9036) "\1c") - (data $165.1 (i32.const 9048) "\02\00\00\00\n\00\00\00M\00A\00X\00_\00U") - (data $166 (i32.const 9068) "\1c") - (data $166.1 (i32.const 9080) "\02\00\00\00\06\00\00\00M\00I\00N") - (data $167 (i32.const 9100) "\1c") - (data $167.1 (i32.const 9112) "\02\00\00\00\n\00\00\00M\00I\00N\00_\00U") - (data $168 (i32.const 9132) ",") - (data $168.1 (i32.const 9144) "\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s") - (data $169 (i32.const 9180) ",") - (data $169.1 (i32.const 9192) "\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h") - (data $170 (i32.const 9228) "<") - (data $170.1 (i32.const 9240) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s") - (data $171 (i32.const 9292) "<") - (data $171.1 (i32.const 9304) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s") - (data $172 (i32.const 9356) "\1c") - (data $172.1 (i32.const 9368) "\14\00\00\00\08\00\00\00\0e") - (data $173 (i32.const 9388) "\1c") - (data $173.1 (i32.const 9400) "\14\00\00\00\08\00\00\00\0f") - (data $174 (i32.const 9420) "\1c") - (data $174.1 (i32.const 9432) "\14\00\00\00\08\00\00\00\10") - (data $175 (i32.const 9452) "\1c") - (data $175.1 (i32.const 9464) "\14\00\00\00\08\00\00\00\11") - (data $176 (i32.const 9484) "\1c") - (data $176.1 (i32.const 9496) "\14\00\00\00\08\00\00\00\12") - (data $177 (i32.const 9516) "\1c") - (data $177.1 (i32.const 9528) "\14\00\00\00\08\00\00\00\13") - (data $178 (i32.const 9548) "\1c") - (data $178.1 (i32.const 9560) "\14\00\00\00\08\00\00\00\14") - (data $179 (i32.const 9580) "\1c") - (data $179.1 (i32.const 9592) "\14\00\00\00\08\00\00\00\15") - (data $180 (i32.const 9612) "\1c") - (data $180.1 (i32.const 9624) "\14\00\00\00\08\00\00\00\16") - (data $181 (i32.const 9644) "\1c") - (data $181.1 (i32.const 9656) "\14\00\00\00\08\00\00\00\17") - (data $182 (i32.const 9676) "\1c") - (data $182.1 (i32.const 9688) "\14\00\00\00\08\00\00\00\18") - (data $183 (i32.const 9708) "\1c") - (data $183.1 (i32.const 9720) "\14\00\00\00\08\00\00\00\19") - (data $184 (i32.const 9740) "\1c") - (data $184.1 (i32.const 9752) "\14\00\00\00\08\00\00\00\1a") - (data $185 (i32.const 9772) "\1c") - (data $185.1 (i32.const 9784) "\14\00\00\00\08\00\00\00\1b") - (data $186 (i32.const 9804) "\1c") - (data $186.1 (i32.const 9816) "\14\00\00\00\08\00\00\00\1c") - (data $187 (i32.const 9836) "\1c") - (data $187.1 (i32.const 9848) "\14\00\00\00\08\00\00\00\1d") - (data $188 (i32.const 9868) "\1c") - (data $188.1 (i32.const 9880) "\14\00\00\00\08\00\00\00\1e") - (data $189 (i32.const 9900) "\1c") - (data $189.1 (i32.const 9912) "\14\00\00\00\08\00\00\00\1f") - (data $190 (i32.const 9932) "\1c") - (data $190.1 (i32.const 9944) "\14\00\00\00\08\00\00\00 ") - (data $191 (i32.const 9964) "\1c") - (data $191.1 (i32.const 9976) "\14\00\00\00\08\00\00\00!") - (data $192 (i32.const 9996) "\1c") - (data $192.1 (i32.const 10008) "\14\00\00\00\08\00\00\00\"") - (data $193 (i32.const 10028) "\1c") - (data $193.1 (i32.const 10040) "\14\00\00\00\08\00\00\00#") - (data $194 (i32.const 10060) "\1c") - (data $194.1 (i32.const 10072) "\14\00\00\00\08\00\00\00$") - (data $195 (i32.const 10092) "\1c") - (data $195.1 (i32.const 10104) "\14\00\00\00\08\00\00\00%") - (data $196 (i32.const 10124) "\1c") - (data $196.1 (i32.const 10136) "\14\00\00\00\08\00\00\00&") - (data $197 (i32.const 10156) "\1c") - (data $197.1 (i32.const 10168) "\14\00\00\00\08\00\00\00\'") - (data $198 (i32.const 10188) "\1c") - (data $198.1 (i32.const 10200) "\14\00\00\00\08\00\00\00(") - (data $199 (i32.const 10220) "\1c") - (data $199.1 (i32.const 10232) "\14\00\00\00\08\00\00\00)") - (data $200 (i32.const 10252) "\1c") - (data $200.1 (i32.const 10264) "\14\00\00\00\08\00\00\00*") - (data $201 (i32.const 10284) "\1c") - (data $201.1 (i32.const 10296) "\14\00\00\00\08\00\00\00+") - (data $202 (i32.const 10316) "\1c") - (data $202.1 (i32.const 10328) "\14\00\00\00\08\00\00\00,") - (data $203 (i32.const 10348) "\1c") - (data $203.1 (i32.const 10360) "\14\00\00\00\08\00\00\00-") - (data $204 (i32.const 10380) "<") - (data $204.1 (i32.const 10392) "\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t") - (data $205 (i32.const 10444) ",") - (data $205.1 (i32.const 10456) "\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s") - (data $206 (i32.const 10492) "|") - (data $206.1 (i32.const 10504) "\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)") - (data $207 (i32.const 10620) "L") - (data $207.1 (i32.const 10632) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s") - (data $208 (i32.const 10700) "\1c") - (data $208.1 (i32.const 10712) "\14\00\00\00\08\00\00\00.") - (data $209 (i32.const 10732) "\1c") - (data $209.1 (i32.const 10744) "\14\00\00\00\08\00\00\00/") - (data $210 (i32.const 10764) "\1c") - (data $210.1 (i32.const 10776) "\14\00\00\00\08\00\00\000") - (data $211 (i32.const 10796) "\1c") - (data $211.1 (i32.const 10808) "\14\00\00\00\08\00\00\001") - (data $212 (i32.const 10828) "\1c") - (data $212.1 (i32.const 10840) "\14\00\00\00\08\00\00\002") - (data $213 (i32.const 10860) "\1c") - (data $213.1 (i32.const 10872) "\14\00\00\00\08\00\00\003") - (data $214 (i32.const 10892) "\1c") - (data $214.1 (i32.const 10904) "\14\00\00\00\08\00\00\004") - (data $215 (i32.const 10924) "\1c") - (data $215.1 (i32.const 10936) "\14\00\00\00\08\00\00\005") - (data $216 (i32.const 10956) "\1c") - (data $216.1 (i32.const 10968) "\14\00\00\00\08\00\00\006") - (data $217 (i32.const 10988) "\1c") - (data $217.1 (i32.const 11000) "\14\00\00\00\08\00\00\007") - (data $218 (i32.const 11020) "\1c") - (data $218.1 (i32.const 11032) "\14\00\00\00\08\00\00\008") - (data $219 (i32.const 11052) "\1c") - (data $219.1 (i32.const 11064) "\14\00\00\00\08\00\00\009") - (data $220 (i32.const 11084) "\1c") - (data $220.1 (i32.const 11096) "\14\00\00\00\08\00\00\00:") - (data $221 (i32.const 11116) "\1c") - (data $221.1 (i32.const 11128) "\14\00\00\00\08\00\00\00;") - (data $222 (i32.const 11148) "\1c") - (data $222.1 (i32.const 11160) "\14\00\00\00\08\00\00\00<") - (data $223 (i32.const 11180) "\1c") - (data $223.1 (i32.const 11192) "\14\00\00\00\08\00\00\00=") - (data $224 (i32.const 11212) "\1c") - (data $224.1 (i32.const 11224) "\14\00\00\00\08\00\00\00>") - (data $225 (i32.const 11244) "\1c") - (data $225.1 (i32.const 11256) "\14\00\00\00\08\00\00\00?") - (data $226 (i32.const 11276) "\1c") - (data $226.1 (i32.const 11288) "\14\00\00\00\08\00\00\00@") - (data $227 (i32.const 11308) "\1c") - (data $227.1 (i32.const 11320) "\14\00\00\00\08\00\00\00A") - (data $228 (i32.const 11340) "\1c") - (data $228.1 (i32.const 11352) "\14\00\00\00\08\00\00\00B") - (data $229 (i32.const 11372) "\1c") - (data $229.1 (i32.const 11384) "\14\00\00\00\08\00\00\00C") - (data $230 (i32.const 11404) "\1c") - (data $230.1 (i32.const 11416) "\14\00\00\00\08\00\00\00D") - (data $231 (i32.const 11436) "\1c") - (data $231.1 (i32.const 11448) "\14\00\00\00\08\00\00\00E") - (data $232 (i32.const 11468) "\1c") - (data $232.1 (i32.const 11480) "\14\00\00\00\08\00\00\00F") - (data $233 (i32.const 11500) "\1c") - (data $233.1 (i32.const 11512) "\14\00\00\00\08\00\00\00G") - (data $234 (i32.const 11532) "\1c") - (data $234.1 (i32.const 11544) "\14\00\00\00\08\00\00\00H") - (data $235 (i32.const 11564) "\1c") - (data $235.1 (i32.const 11576) "\14\00\00\00\08\00\00\00I") - (data $236 (i32.const 11596) "\1c") - (data $236.1 (i32.const 11608) "\14\00\00\00\08\00\00\00J") - (data $237 (i32.const 11628) "\1c") - (data $237.1 (i32.const 11640) "\14\00\00\00\08\00\00\00K") - (data $238 (i32.const 11660) "\1c") - (data $238.1 (i32.const 11672) "\14\00\00\00\08\00\00\00L") - (data $239 (i32.const 11692) "\1c") - (data $239.1 (i32.const 11704) "\14\00\00\00\08\00\00\00M") - (data $240 (i32.const 11724) "\1c") - (data $240.1 (i32.const 11736) "\14\00\00\00\08\00\00\00N") - (data $241 (i32.const 11756) "\1c") - (data $241.1 (i32.const 11768) "\14\00\00\00\08\00\00\00O") - (data $242 (i32.const 11788) "\1c") - (data $242.1 (i32.const 11800) "\14\00\00\00\08\00\00\00P") - (data $243 (i32.const 11820) "\1c") - (data $243.1 (i32.const 11832) "\14\00\00\00\08\00\00\00Q") - (data $244 (i32.const 11852) "\1c") - (data $244.1 (i32.const 11864) "\14\00\00\00\08\00\00\00R") - (data $245 (i32.const 11884) "\1c") - (data $245.1 (i32.const 11896) "\14\00\00\00\08\00\00\00S") - (data $246 (i32.const 11916) "\1c") - (data $246.1 (i32.const 11928) "\14\00\00\00\08\00\00\00T") - (data $247 (i32.const 11948) "\1c") - (data $247.1 (i32.const 11960) "\14\00\00\00\08\00\00\00U") - (data $248 (i32.const 11980) "\1c") - (data $248.1 (i32.const 11992) "\14\00\00\00\08\00\00\00V") - (data $249 (i32.const 12012) "\1c") - (data $249.1 (i32.const 12024) "\14\00\00\00\08\00\00\00W") - (data $250 (i32.const 12044) "\1c") - (data $250.1 (i32.const 12056) "\14\00\00\00\08\00\00\00X") - (data $251 (i32.const 12076) "\1c") - (data $251.1 (i32.const 12088) "\14\00\00\00\08\00\00\00Y") - (data $252 (i32.const 12108) "\1c") - (data $252.1 (i32.const 12120) "\14\00\00\00\08\00\00\00Z") - (data $253 (i32.const 12140) "\1c") - (data $253.1 (i32.const 12152) "\14\00\00\00\08\00\00\00[") - (data $254 (i32.const 12172) "\1c") - (data $254.1 (i32.const 12184) "\14\00\00\00\08\00\00\00\\") - (data $255 (i32.const 12204) "\1c") - (data $255.1 (i32.const 12216) "\14\00\00\00\08\00\00\00]") - (data $256 (i32.const 12236) "\1c") - (data $256.1 (i32.const 12248) "\14\00\00\00\08\00\00\00^") - (data $257 (i32.const 12268) "\1c") - (data $257.1 (i32.const 12280) "\14\00\00\00\08\00\00\00_") - (data $258 (i32.const 12300) "\1c") - (data $258.1 (i32.const 12312) "\14\00\00\00\08\00\00\00`") - (data $259 (i32.const 12332) "\1c") - (data $259.1 (i32.const 12344) "\14\00\00\00\08\00\00\00a") - (data $260 (i32.const 12364) "\1c") - (data $260.1 (i32.const 12376) "\14\00\00\00\08\00\00\00b") - (data $261 (i32.const 12396) "\1c") - (data $261.1 (i32.const 12408) "\14\00\00\00\08\00\00\00c") - (data $262 (i32.const 12428) ",") - (data $262.1 (i32.const 12440) "\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y") - (data $263 (i32.const 12476) "\\") - (data $263.1 (i32.const 12488) "\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.") - (data $264 (i32.const 12572) "\1c") - (data $264.1 (i32.const 12584) "\14\00\00\00\08\00\00\00d") - (data $265 (i32.const 12604) "\1c") - (data $265.1 (i32.const 12616) "\14\00\00\00\08\00\00\00e") - (data $266 (i32.const 12636) "\1c") - (data $266.1 (i32.const 12648) "\14\00\00\00\08\00\00\00f") - (data $267 (i32.const 12668) "\1c") - (data $267.1 (i32.const 12680) "\14\00\00\00\08\00\00\00g") - (data $268 (i32.const 12700) "\1c") - (data $268.1 (i32.const 12712) "\14\00\00\00\08\00\00\00h") - (data $269 (i32.const 12732) "\1c") - (data $269.1 (i32.const 12744) "\14\00\00\00\08\00\00\00i") - (data $270 (i32.const 12764) "\1c") - (data $270.1 (i32.const 12776) "\14\00\00\00\08\00\00\00j") - (data $271 (i32.const 12796) "\1c") - (data $271.1 (i32.const 12808) "\14\00\00\00\08\00\00\00k") - (data $272 (i32.const 12828) "\1c") - (data $272.1 (i32.const 12840) "\14\00\00\00\08\00\00\00l") - (data $273 (i32.const 12860) "\1c") - (data $273.1 (i32.const 12872) "\14\00\00\00\08\00\00\00m") - (data $274 (i32.const 12892) "\1c") - (data $274.1 (i32.const 12904) "\14\00\00\00\08\00\00\00n") - (data $275 (i32.const 12924) "\1c") - (data $275.1 (i32.const 12936) "\14\00\00\00\08\00\00\00o") - (data $276 (i32.const 12956) "\1c") - (data $276.1 (i32.const 12968) "\14\00\00\00\08\00\00\00p") - (data $277 (i32.const 12988) "\1c") - (data $277.1 (i32.const 13000) "\14\00\00\00\08\00\00\00q") - (data $278 (i32.const 13020) "\1c") - (data $278.1 (i32.const 13032) "\14\00\00\00\08\00\00\00r") - (data $279 (i32.const 13052) "\1c") - (data $279.1 (i32.const 13064) "\14\00\00\00\08\00\00\00s") - (data $280 (i32.const 13084) "\1c") - (data $280.1 (i32.const 13096) "\14\00\00\00\08\00\00\00t") - (data $281 (i32.const 13116) "\1c") - (data $281.1 (i32.const 13128) "\14\00\00\00\08\00\00\00u") - (data $282 (i32.const 13148) "\1c") - (data $282.1 (i32.const 13160) "\14\00\00\00\08\00\00\00v") - (data $283 (i32.const 13180) "\1c") - (data $283.1 (i32.const 13192) "\14\00\00\00\08\00\00\00w") - (data $284 (i32.const 13212) "\1c") - (data $284.1 (i32.const 13224) "\14\00\00\00\08\00\00\00x") - (data $285 (i32.const 13244) "\1c") - (data $285.1 (i32.const 13256) "\14\00\00\00\08\00\00\00y") - (data $286 (i32.const 13276) "\1c") - (data $286.1 (i32.const 13288) "\14\00\00\00\08\00\00\00z") - (data $287 (i32.const 13308) "\1c") - (data $287.1 (i32.const 13320) "\14\00\00\00\08\00\00\00{") - (data $288 (i32.const 13340) "\1c") - (data $288.1 (i32.const 13352) "\14\00\00\00\08\00\00\00|") - (data $289 (i32.const 13372) "\1c") - (data $289.1 (i32.const 13384) "\14\00\00\00\08\00\00\00}") - (data $290 (i32.const 13404) "\1c") - (data $290.1 (i32.const 13416) "\14\00\00\00\08\00\00\00~") - (data $291 (i32.const 13436) "\1c") - (data $291.1 (i32.const 13448) "\14\00\00\00\08\00\00\00\7f") - (data $292 (i32.const 13468) "\1c") - (data $292.1 (i32.const 13480) "\14\00\00\00\08\00\00\00\80") - (data $293 (i32.const 13500) "\1c") - (data $293.1 (i32.const 13512) "\14\00\00\00\08\00\00\00\81") - (data $294 (i32.const 13532) "\1c") - (data $294.1 (i32.const 13544) "\14\00\00\00\08\00\00\00\82") - (data $295 (i32.const 13564) "\1c") - (data $295.1 (i32.const 13576) "\14\00\00\00\08\00\00\00\83") - (data $296 (i32.const 13596) "\1c") - (data $296.1 (i32.const 13608) "\14\00\00\00\08\00\00\00\84") - (data $297 (i32.const 13628) "\1c") - (data $297.1 (i32.const 13640) "\14\00\00\00\08\00\00\00\85") - (data $298 (i32.const 13660) "\1c") - (data $298.1 (i32.const 13672) "\14\00\00\00\08\00\00\00\86") - (data $299 (i32.const 13692) "\1c") - (data $299.1 (i32.const 13704) "\14\00\00\00\08\00\00\00\87") - (data $300 (i32.const 13724) "\1c") - (data $300.1 (i32.const 13736) "\14\00\00\00\08\00\00\00\88") - (data $301 (i32.const 13756) "\1c") - (data $301.1 (i32.const 13768) "\14\00\00\00\08\00\00\00\89") - (data $302 (i32.const 13788) "\1c") - (data $302.1 (i32.const 13800) "\14\00\00\00\08\00\00\00\8a") - (data $303 (i32.const 13820) "\1c") - (data $303.1 (i32.const 13832) "\14\00\00\00\08\00\00\00\8b") - (data $304 (i32.const 13852) "\1c") - (data $304.1 (i32.const 13864) "\14\00\00\00\08\00\00\00\8c") - (data $305 (i32.const 13884) "\1c") - (data $305.1 (i32.const 13896) "\14\00\00\00\08\00\00\00\8d") - (data $306 (i32.const 13916) "\1c") - (data $306.1 (i32.const 13928) "\14\00\00\00\08\00\00\00\8e") - (data $307 (i32.const 13948) "\1c") - (data $307.1 (i32.const 13960) "\14\00\00\00\08\00\00\00\8f") - (data $308 (i32.const 13980) "\1c") - (data $308.1 (i32.const 13992) "\14\00\00\00\08\00\00\00\90") - (data $309 (i32.const 14012) "\1c") - (data $309.1 (i32.const 14024) "\14\00\00\00\08\00\00\00\91") - (data $310 (i32.const 14044) "\1c") - (data $310.1 (i32.const 14056) "\14\00\00\00\08\00\00\00\92") - (data $311 (i32.const 14076) "\1c") - (data $311.1 (i32.const 14088) "\14\00\00\00\08\00\00\00\93") - (data $312 (i32.const 14108) "\1c") - (data $312.1 (i32.const 14120) "\14\00\00\00\08\00\00\00\94") - (data $313 (i32.const 14140) "\1c") - (data $313.1 (i32.const 14152) "\14\00\00\00\08\00\00\00\95") - (data $314 (i32.const 14172) "\1c") - (data $314.1 (i32.const 14184) "\14\00\00\00\08\00\00\00\96") - (data $315 (i32.const 14204) "\1c") - (data $315.1 (i32.const 14216) "\14\00\00\00\08\00\00\00\97") - (data $316 (i32.const 14236) "\1c") - (data $316.1 (i32.const 14248) "\14\00\00\00\08\00\00\00\98") - (data $317 (i32.const 14268) "\1c") - (data $317.1 (i32.const 14280) "\14\00\00\00\08\00\00\00\99") - (data $318 (i32.const 14300) "\ac\03") - (data $318.1 (i32.const 14312) "\01\00\00\00\9c\03\00\00@0\00\00`0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\800\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00`(\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\f05\00\00\106\00\0006\00\00P6\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\e0\'\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\00(\00\00\80(\00\00\e0)\00\00\00*\00\00 *\00\00@*\00\00`*\00\00\80*\00\00\a0*\00\00p6\00\00\906\00\00\b06\00\00\d06\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\f06\00\00\107\00\0007\00\00P7\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 (\00\00\e0%\00\00\00&\00\00 &\00\00@&\00\00`&\00\00\80&\00\00\a0&\00\00\c0&\00\00\e0&\00\00\00\'\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00P1\00\0001\00\00\a0$\00\00\c0$\00\00\e0$\00\00\00%\00\00 %\00\00@%\00\00`%\00\00\80%\00\00\a0%\00\00\c0%\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00p7\00\00\907\00\00\b07\00\00\d07\00\00\c0*\00\00\e0*\00\00\00+\00\00 +\00\00@+\00\00`+\00\00\80+\00\00\c0,\00\00\a0+\00\00\c0+\00\00\e0+\00\00\e0,\00\00\f02\00\00\103\00\00\b03\00\00\d03\00\00\f03\00\00\00-\00\0003\00\00P3\00\00\104\00\0004\00\00P4\00\00p1\00\00\901\00\00 -\00\00@-\00\00p4\00\00\904\00\00\b04\00\00`-\00\00\d04\00\00\f04\00\00\105\00\00\f01\00\00\102\00\0002\00\00P2\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 \'\00\00@\'\00\00`\'\00\00\80\'\00\00\a0\'\00\00\c0\'\00\00 0\00\00 0\00\00 0\00\00 0\00\00@(\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00 0\00\00\80-\00\00\a0-\00\00\c0-\00\00\e0-\00\00\00.\00\00 .\00\00@.\00\0005\00\00P5\00\00p5\00\00`.\00\00\80.\00\00\a0.\00\00\c0.\00\00\e0.\00\00\00/\00\00 /\00\00\905\00\00\b05\00\00\d05\00\00\00,\00\00 ,\00\00@,\00\00@/\00\00`/\00\00\80/\00\00p3\00\00\903\00\00\b01\00\00\d01\00\00p2\00\00\902\00\00\b02\00\00\d02\00\00`,\00\00\80,\00\00\a0,\00\00\a0/\00\00\c0/\00\00\e0/\00\00\000") - (data $319 (i32.const 15244) ",") - (data $319.1 (i32.const 15256) "\1a\00\00\00\10\00\00\00\f07\00\00\f07\00\00\9c\03\00\00\e7") - (data $320 (i32.const 15292) "\1c") - (data $320.1 (i32.const 15304) "\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80") - (data $321 (i32.const 15324) ",") - (data $321.1 (i32.const 15336) "\1b\00\00\00\10\00\00\00\d0;\00\00\d0;\00\00\08\00\00\00\08") - (data $322 (i32.const 15372) "\1c") - (data $322.1 (i32.const 15384) "\1c\00\00\00\08\00\00\00\9a") - (data $323 (i32.const 15404) "L") - (data $323.1 (i32.const 15416) "\02\00\00\00:\00\00\00<\00s\00e\00e\00m\00s\00 \00t\00h\00a\00t\00 \00t\00h\00e\00r\00e\00 \00i\00s\00 \00n\00o\00 \00c\00o\00d\00e\00>") - (data $324 (i32.const 15484) "\1c") - (data $324.1 (i32.const 15496) "\02") - (data $325 (i32.const 15516) "l") - (data $325.1 (i32.const 15528) "\02\00\00\00R\00\00\00W\00e\00 \00s\00h\00o\00u\00l\00d\00 \00i\00t\00e\00r\00a\00t\00e\00 \00o\00n\00l\00y\00 \00o\00v\00e\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00s\00!") - (data $326 (i32.const 15628) "L") - (data $326.1 (i32.const 15640) "\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00i\00n\00t\00e\00r\00n\00a\00l\00.\00t\00s") - (data $327 (i32.const 15708) "|") - (data $327.1 (i32.const 15720) "\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y") - (data $328 (i32.const 15836) "\1c") - (data $328.1 (i32.const 15848) "\02\00\00\00\02\00\00\00\n") - (data $329 (i32.const 15868) "|") - (data $329.1 (i32.const 15880) "\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006") - (data $330 (i32.const 15996) "<") - (data $330.1 (i32.const 16008) "\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s") - (data $331 (i32.const 16060) "\1c") - (data $331.1 (i32.const 16072) "\02\00\00\00\02\00\00\000") - (data $332 (i32.const 16092) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009") - (data $333 (i32.const 16492) "\1c\04") - (data $333.1 (i32.const 16504) "\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f") - (data $334 (i32.const 17548) "\\") - (data $334.1 (i32.const 17560) "\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z") - (data $335 (i32.const 17644) "\1c") - (data $335.1 (i32.const 17656) "\02\00\00\00\04\00\00\00:\00 ") - (data $336 (i32.const 17676) "\1c") - (data $336.1 (i32.const 17688) "\02\00\00\00\02\00\00\00(") - (data $337 (i32.const 17708) "\1c") - (data $337.1 (i32.const 17720) "\02\00\00\00\02\00\00\00)") - (data $338 (i32.const 17740) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00 E\00\00\00\00\00\00@E") - (data $339 (i32.const 17772) "\1c") - (data $339.1 (i32.const 17784) "\02\00\00\00\02\00\00\00 ") - (data $340 (i32.const 17804) "\1c") - (data $340.1 (i32.const 17816) "\02\00\00\00\04\00\00\00,\00 ") - (data $341 (i32.const 17836) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\80E\00\00\00\00\00\00\a0E") - (data $342 (i32.const 17868) "L") - (data $342.1 (i32.const 17880) "\02\00\00\004\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00k\00i\00n\00d\00:\00 ") - (data $343 (i32.const 17948) "L") - (data $343.1 (i32.const 17960) "\02\00\00\002\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00-\00b\00u\00i\00l\00d\00.\00t\00s") - (data $344 (i32.const 18028) "\1c") - (data $344.1 (i32.const 18040) "\01") - (data $345 (i32.const 18060) "<") - (data $345.1 (i32.const 18072) "\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00d\00a\00t\00a\00v\00i\00e\00w\00.\00t\00s") - (data $346 (i32.const 18124) "L") - (data $346.1 (i32.const 18136) "\02\00\00\006\00\00\00U\00n\00h\00a\00n\00d\00l\00e\00d\00 \00n\00u\00m\00b\00e\00r\00 \00e\00n\00c\00o\00d\00i\00n\00g\00:\00 ") - (data $347 (i32.const 18204) "<") - (data $347.1 (i32.const 18216) "\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s") - (data $348 (i32.const 18268) "L") - (data $348.1 (i32.const 18280) "\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 ") - (data $349 (i32.const 18348) ",") - (data $349.1 (i32.const 18360) "\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 ") - (data $350 (i32.const 18396) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00pG\00\00\00\00\00\00\c0G") - (data $351 (i32.const 18444) "l") - (data $351.1 (i32.const 18456) "\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 ") - (data $352 (i32.const 18556) ",") - (data $352.1 (i32.const 18568) "\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 ") - (data $353 (i32.const 18604) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00 H\00\00\00\00\00\00\90H") - (data $354 (i32.const 18652) "\\") - (data $354.1 (i32.const 18664) "\02\00\00\00D\00\00\00A\00r\00g\00u\00m\00e\00n\00t\00s\00 \00l\00e\00n\00g\00t\00h\00 \00i\00s\00 \00t\00o\00o\00 \00b\00i\00g\00.\00 \00G\00o\00t\00:\00 ") - (data $355 (i32.const 18748) ",") - (data $355.1 (i32.const 18760) "\02\00\00\00\0e\00\00\00,\00 \00m\00a\00x\00:\00 ") - (data $356 (i32.const 18796) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00\f0H\00\00\00\00\00\00PI") - (data $357 (i32.const 18844) "<") - (data $357.1 (i32.const 18856) "\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00s\00p\00i\00.\00t\00s") - (data $358 (i32.const 18908) "|") - (data $358.1 (i32.const 18920) "\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 ") - (data $359 (i32.const 19036) "\1c") - (data $359.1 (i32.const 19048) "\01") - (data $360 (i32.const 19068) "\\") - (data $360.1 (i32.const 19080) "\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 ") - (data $361 (i32.const 19164) "<") - (data $361.1 (i32.const 19176) "\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s") - (data $362 (i32.const 19228) "l") - (data $362.1 (i32.const 19240) "\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!") - (data $363 (i32.const 19340) "L") - (data $363.1 (i32.const 19352) "\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00d\00e\00b\00u\00g\00g\00e\00r\00.\00t\00s") - (data $364 (i32.const 19420) "\\") - (data $364.1 (i32.const 19432) "\02\00\00\00D\00\00\00M\00i\00s\00m\00a\00t\00c\00h\00i\00n\00g\00 \00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00 \00s\00i\00z\00e\00,\00 \00g\00o\00t\00:\00 ") - (data $365 (i32.const 19516) ",") - (data $365.1 (i32.const 19528) "\02\00\00\00\18\00\00\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 ") - (data $366 (i32.const 19564) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\10\00\00\00\f0K\00\00\00\00\00\00PL") - (data $367 (i32.const 19612) "\1c") - (data $367.1 (i32.const 19624) "\01") - (data $368 (i32.const 19644) "\1c") - (data $368.1 (i32.const 19656) "\01") - (data $369 (i32.const 19676) "\1c") - (data $369.1 (i32.const 19688) "\01") - (data $370 (i32.const 19708) ",") - (data $370.1 (i32.const 19720) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00r\00e\00s\00u\00l\00t") - (data $371 (i32.const 19756) "L") - (data $371.1 (i32.const 19768) "\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00i\00n\00t\00e\00r\00p\00r\00e\00t\00e\00r\00.\00t\00s") - (data $372 (i32.const 19836) "\1c") - (data $372.1 (i32.const 19848) "\01") - (data $373 (i32.const 19868) "\1c") - (data $373.1 (i32.const 19880) "\01") - (data $374 (i32.const 19900) "\1c") - (data $374.1 (i32.const 19912) "\01") - (data $375 (i32.const 19932) "\1c") - (data $375.1 (i32.const 19944) "\01") - (data $376 (i32.const 19964) ",") - (data $376.1 (i32.const 19976) "\02\00\00\00\1c\00\00\00U\00n\00k\00n\00o\00w\00n\00 \00k\00i\00n\00d\00:\00 ") - (data $377 (i32.const 20012) "<") - (data $377.1 (i32.const 20024) "\02\00\00\00*\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00a\00p\00i\00-\00u\00t\00i\00l\00s\00.\00t\00s") - (data $378 (i32.const 20076) "<") - (data $378.1 (i32.const 20088) "\02\00\00\00*\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00g\00a\00s\00-\00c\00o\00s\00t\00s\00.\00t\00s") - (data $379 (i32.const 20140) "\1c") - (data $379.1 (i32.const 20152) "\01") - (data $380 (i32.const 20172) "\1c") - (data $380.1 (i32.const 20184) "\01") - (data $381 (i32.const 20204) "\1c") - (data $381.1 (i32.const 20216) "\01") - (data $382 (i32.const 20236) "\1c") - (data $382.1 (i32.const 20248) "\01") - (data $383 (i32.const 20268) ",") - (data $383.1 (i32.const 20280) "\02\00\00\00\16\00\00\00M\00e\00t\00a\00d\00a\00t\00a\00:\00 \00\n") - (data $384 (i32.const 20316) "\1c") - (data $384.1 (i32.const 20328) "\02\00\00\00\04\00\00\000\00x") - (data $385 (i32.const 20348) "\1c") - (data $385.1 (i32.const 20360) ":\00\00\00\08\00\00\00\9b") - (data $386 (i32.const 20380) "\1c") - (data $386.1 (i32.const 20392) "\02\00\00\00\04\00\00\00\n\00\n") - (data $387 (i32.const 20412) ",") - (data $387.1 (i32.const 20424) "\02\00\00\00\18\00\00\00R\00E\00G\00I\00S\00T\00E\00R\00S\00 \00=\00 ") - (data $388 (i32.const 20460) ",") - (data $388.1 (i32.const 20472) "\02\00\00\00\10\00\00\00 \00(\00f\00i\00n\00a\00l\00)") - (data $389 (i32.const 20508) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\d0O\00\00\00\00\00\00\00P") - (data $390 (i32.const 20540) "\1c\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\0c\00\00\00\d0O\00\00\00\00\00\00\00P") - (data $391 (i32.const 20572) "\1c") - (data $391.1 (i32.const 20584) ">\00\00\00\08\00\00\00\9c") - (data $392 (i32.const 20604) "<") - (data $392.1 (i32.const 20616) "\02\00\00\00,\00\00\00F\00i\00n\00i\00s\00h\00e\00d\00 \00w\00i\00t\00h\00 \00s\00t\00a\00t\00u\00s\00:\00 ") - (data $393 (i32.const 20668) ",") - (data $393.1 (i32.const 20680) "\02\00\00\00\16\00\00\00E\00x\00i\00t\00 \00c\00o\00d\00e\00:\00 ") - (data $394 (i32.const 20716) "\1c") - (data $394.1 (i32.const 20728) "\02\00\00\00\n\00\00\00P\00C\00 \00=\00 ") - (data $395 (i32.const 20748) "\1c") - (data $395.1 (i32.const 20760) "\02\00\00\00\0c\00\00\00G\00A\00S\00 \00=\00 ") - (data $396 (i32.const 20780) ",") - (data $396.1 (i32.const 20792) "\02\00\00\00\12\00\00\00S\00T\00A\00T\00U\00S\00 \00=\00 ") - (data $397 (i32.const 20828) "\1c") - (data $397.1 (i32.const 20840) ">\00\00\00\08\00\00\00\9d") - (data $398 (i32.const 20860) ",") - (data $398.1 (i32.const 20872) "\02\00\00\00\1c\00\00\00I\00N\00S\00T\00R\00U\00C\00T\00I\00O\00N\00 \00=\00 ") - (data $399 (i32.const 20908) "\1c") - (data $399.1 (i32.const 20920) "\02\00\00\00\04\00\00\00 \00(") - (data $400 (i32.const 20940) ",\00\00\00\03\00\00\00\00\00\00\00%\00\00\00\14\00\00\00\90Q\00\00\00\00\00\00\c0Q\00\00\00\00\00\00@E") - (data $401 (i32.const 20988) "<") - (data $401.1 (i32.const 21000) "\02\00\00\00&\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s") - (data $402 (i32.const 21052) ",") - (data $402.1 (i32.const 21064) "\02\00\00\00\1a\00\00\00A\00R\00G\00U\00M\00E\00N\00T\00S\00:\00\n\00 \00 ") - (data $403 (i32.const 21100) "\1c") - (data $403.1 (i32.const 21112) "\02\00\00\00\0c\00\00\00)\00 \00=\00 \000\00x") - (data $404 (i32.const 21132) "\1c") - (data $404.1 (i32.const 21144) "\02\00\00\00\n\00\00\00,\00 \00\n\00 \00 ") - (data $405 (i32.const 21164) "\1c") - (data $405.1 (i32.const 21176) "\02\00\00\00\08\00\00\00,\00\n\00 \00 ") - (data $406 (i32.const 21196) "|\00\00\00\03\00\00\00\00\00\00\00%\00\00\00`\00\00\00PR\00\00\00\00\00\00\c0Q\00\00\00\00\00\00\80R\00\00\00\00\00\00\a0R\00\00\00\00\00\00\c0Q\00\00\00\00\00\00\80R\00\00\00\00\00\00\c0R\00\00\00\00\00\00\c0Q\00\00\00\00\00\00\80R\00\00\00\00\00\00\c0R\00\00\00\00\00\00\c0Q\00\00\00\00\00\00\80R") - (data $407 (i32.const 21324) "\1c") - (data $407.1 (i32.const 21336) "\01") - (data $408 (i32.const 21356) "\1c") - (data $408.1 (i32.const 21368) "\01") - (data $409 (i32.const 21388) "\1c") - (data $409.1 (i32.const 21400) "\01") - (data $410 (i32.const 21420) "<") - (data $410.1 (i32.const 21432) "\02\00\00\00*\00\00\00O\00b\00j\00e\00c\00t\00 \00a\00l\00r\00e\00a\00d\00y\00 \00p\00i\00n\00n\00e\00d") - (data $411 (i32.const 21484) "<") - (data $411.1 (i32.const 21496) "\02\00\00\00(\00\00\00O\00b\00j\00e\00c\00t\00 \00i\00s\00 \00n\00o\00t\00 \00p\00i\00n\00n\00e\00d") - (data $412 (i32.const 21552) "@\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00\02\01\00\00 ") - (data $412.1 (i32.const 21612) "$\02") - (data $412.2 (i32.const 21624) "\02A\00\00\10A\02\00 ") - (data $412.3 (i32.const 21648) "d") - (data $412.4 (i32.const 21660) "\02A\00\00B") - (data $412.5 (i32.const 21684) "$\01") - (data $412.6 (i32.const 21696) "$\t\00\00 \00\00\00\04A\00\00\02\01\00\00d") - (data $412.7 (i32.const 21728) " ") - (data $412.8 (i32.const 21740) " \00\00\00\02A\00\00 \00\00\00\02A\00\00\00\00\00\00\02A\00\00 \00\00\00 \00\00\00 \00\00\00\02A\00\00\02\02\00\00\10A\02") - (data $412.9 (i32.const 21800) "\02A") - (table $0 158 158 funcref) - (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/codec~anonymous|0 $assembly/api-utils/disassemble~anonymous|0 $assembly/api-internal/executeProgram~anonymous|0 $assembly/api-internal/executeProgram~anonymous|0) - (export "nextStep" (func $assembly/api-debugger/nextStep)) - (export "nSteps" (func $assembly/api-debugger/nSteps)) - (export "getProgramCounter" (func $assembly/api-debugger/getProgramCounter)) - (export "setNextProgramCounter" (func $assembly/api-debugger/setNextProgramCounter)) - (export "getStatus" (func $assembly/api-debugger/getStatus)) - (export "getExitArg" (func $assembly/api-debugger/getExitArg)) - (export "getGasLeft" (func $assembly/api-debugger/getGasLeft)) - (export "setGasLeft" (func $assembly/api-debugger/setGasLeft)) - (export "getRegister" (func $assembly/api-debugger/getRegister)) - (export "setRegister" (func $assembly/api-debugger/setRegister)) - (export "getRegisters" (func $assembly/api-debugger/getRegisters)) - (export "getPageDump" (func $assembly/api-debugger/getPageDump)) - (export "getMemory" (func $assembly/api-debugger/getMemory)) - (export "InputKind.Generic" (global $assembly/api-utils/InputKind.Generic)) - (export "InputKind.SPI" (global $assembly/api-utils/InputKind.SPI)) - (export "HasMetadata.Yes" (global $assembly/api-utils/HasMetadata.Yes)) - (export "HasMetadata.No" (global $assembly/api-utils/HasMetadata.No)) - (export "__new" (func $~lib/rt/itcms/__new)) - (export "__pin" (func $~lib/rt/itcms/__pin)) - (export "__unpin" (func $~lib/rt/itcms/__unpin)) - (export "__collect" (func $~lib/rt/itcms/__collect)) - (export "__rtti_base" (global $~lib/rt/__rtti_base)) - (export "memory" (memory $0)) - (export "__setArgumentsLength" (func $~setArgumentsLength)) - (export "getAssembly" (func $export:assembly/api-internal/getAssembly)) - (export "wrapAsProgram" (func $export:assembly/program-build/wrapAsProgram)) - (export "resetJAM" (func $export:assembly/api-debugger/resetJAM@varargs)) - (export "resetGeneric" (func $export:assembly/api-debugger/resetGeneric@varargs)) - (export "resetGenericWithMemory" (func $export:assembly/api-debugger/resetGenericWithMemory@varargs)) - (export "setRegisters" (func $export:assembly/api-debugger/setRegisters)) - (export "setMemory" (func $export:assembly/api-debugger/setMemory)) - (export "getGasCosts" (func $export:assembly/api-utils/getGasCosts)) - (export "disassemble" (func $export:assembly/api-utils/disassemble)) - (export "prepareProgram" (func $export:assembly/api-utils/prepareProgram)) - (export "runProgram" (func $export:assembly/api-utils/runProgram@varargs)) - (start $~start) - (func $~lib/rt/itcms/visitRoots - (local $0 i32) - (local $1 i32) - i32.const 1504 - call $~lib/rt/itcms/__visit - i32.const 9200 - call $~lib/rt/itcms/__visit - i32.const 12448 - call $~lib/rt/itcms/__visit - i32.const 15728 - call $~lib/rt/itcms/__visit - i32.const 10400 - call $~lib/rt/itcms/__visit - i32.const 1312 - call $~lib/rt/itcms/__visit - i32.const 21440 - call $~lib/rt/itcms/__visit - i32.const 21504 - call $~lib/rt/itcms/__visit - i32.const 16512 - call $~lib/rt/itcms/__visit - i32.const 17568 - call $~lib/rt/itcms/__visit - global.get $assembly/api-debugger/interpreter - local.tee $0 - if - local.get $0 - call $~lib/rt/itcms/__visit - end - i32.const 15344 - call $~lib/rt/itcms/__visit - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $0 - if - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $0 - if - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_PAGE - local.tee $0 - if - local.get $0 - call $~lib/rt/itcms/__visit - end - i32.const 1136 - call $~lib/rt/itcms/__visit - i32.const 1264 - call $~lib/rt/itcms/__visit - i32.const 2272 - call $~lib/rt/itcms/__visit - global.get $assembly/instructions/INSTRUCTIONS - local.tee $0 - if - local.get $0 - call $~lib/rt/itcms/__visit - end - i32.const 15264 - call $~lib/rt/itcms/__visit - global.get $~lib/rt/itcms/pinSpace - local.tee $1 - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - loop $while-continue|0 - local.get $0 - local.get $1 - i32.ne - if - local.get $0 - i32.load offset=4 - i32.const 3 - i32.and - i32.const 3 - i32.ne - if - i32.const 0 - i32.const 1376 - i32.const 160 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.const 20 - i32.add - call $~lib/rt/__visit_members - local.get $0 - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - br $while-continue|0 - end - end - ) - (func $~lib/rt/itcms/Object#unlink (param $0 i32) - (local $1 i32) - local.get $0 - i32.load offset=4 - i32.const -4 - i32.and - local.tee $1 - i32.eqz - if - local.get $0 - i32.load offset=8 - i32.eqz - local.get $0 - i32.const 54580 - i32.lt_u - i32.and - i32.eqz - if - i32.const 0 - i32.const 1376 - i32.const 128 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - return - end - local.get $0 - i32.load offset=8 - local.tee $0 - i32.eqz - if - i32.const 0 - i32.const 1376 - i32.const 132 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $1 - local.get $0 - i32.store offset=8 - local.get $0 - local.get $1 - local.get $0 - i32.load offset=4 - i32.const 3 - i32.and - i32.or - i32.store offset=4 - ) - (func $~lib/rt/itcms/Object#makeGray (param $0 i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - local.get $0 - global.get $~lib/rt/itcms/iter - i32.eq - if - local.get $0 - i32.load offset=8 - local.tee $1 - i32.eqz - if - i32.const 0 - i32.const 1376 - i32.const 148 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.get $1 - global.set $~lib/rt/itcms/iter - end - local.get $0 - call $~lib/rt/itcms/Object#unlink - global.get $~lib/rt/itcms/toSpace - local.set $1 - local.get $0 - i32.load offset=12 - local.tee $2 - i32.const 2 - i32.le_u - if (result i32) - i32.const 1 - else - local.get $2 - i32.const 21552 - i32.load - i32.gt_u - if - i32.const 1504 - i32.const 1568 - i32.const 21 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $2 - i32.const 2 - i32.shl - i32.const 21556 - i32.add - i32.load - i32.const 32 - i32.and - end - local.set $3 - local.get $1 - i32.load offset=8 - local.set $2 - local.get $0 - global.get $~lib/rt/itcms/white - i32.eqz - i32.const 2 - local.get $3 - select - local.get $1 - i32.or - i32.store offset=4 - local.get $0 - local.get $2 - i32.store offset=8 - local.get $2 - local.get $0 - local.get $2 - i32.load offset=4 - i32.const 3 - i32.and - i32.or - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=8 - ) - (func $~lib/rt/itcms/__visit (param $0 i32) - local.get $0 - i32.eqz - if - return - end - global.get $~lib/rt/itcms/white - local.get $0 - i32.const 20 - i32.sub - local.tee $0 - i32.load offset=4 - i32.const 3 - i32.and - i32.eq - if - local.get $0 - call $~lib/rt/itcms/Object#makeGray - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.add - global.set $~lib/rt/itcms/visitCount - end - ) - (func $~lib/rt/tlsf/removeBlock (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - local.get $1 - i32.load - local.tee $3 - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 268 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.const -4 - i32.and - local.tee $3 - i32.const 12 - i32.lt_u - if - i32.const 0 - i32.const 1648 - i32.const 270 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.const 256 - i32.lt_u - if (result i32) - local.get $3 - i32.const 4 - i32.shr_u - else - i32.const 31 - i32.const 1073741820 - local.get $3 - local.get $3 - i32.const 1073741820 - i32.ge_u - select - local.tee $3 - i32.clz - i32.sub - local.tee $4 - i32.const 7 - i32.sub - local.set $2 - local.get $3 - local.get $4 - i32.const 4 - i32.sub - i32.shr_u - i32.const 16 - i32.xor - end - local.tee $3 - i32.const 16 - i32.lt_u - local.get $2 - i32.const 23 - i32.lt_u - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 284 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.load offset=8 - local.set $5 - local.get $1 - i32.load offset=4 - local.tee $4 - if - local.get $4 - local.get $5 - i32.store offset=8 - end - local.get $5 - if - local.get $5 - local.get $4 - i32.store offset=4 - end - local.get $1 - local.get $0 - local.get $2 - i32.const 4 - i32.shl - local.get $3 - i32.add - i32.const 2 - i32.shl - i32.add - local.tee $1 - i32.load offset=96 - i32.eq - if - local.get $1 - local.get $5 - i32.store offset=96 - local.get $5 - i32.eqz - if - local.get $0 - local.get $2 - i32.const 2 - i32.shl - i32.add - local.tee $1 - i32.load offset=4 - i32.const -2 - local.get $3 - i32.rotl - i32.and - local.set $3 - local.get $1 - local.get $3 - i32.store offset=4 - local.get $3 - i32.eqz - if - local.get $0 - local.get $0 - i32.load - i32.const -2 - local.get $2 - i32.rotl - i32.and - i32.store - end - end - end - ) - (func $~lib/rt/tlsf/insertBlock (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - local.get $1 - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 201 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.load - local.tee $3 - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 203 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.const 4 - i32.add - local.get $1 - i32.load - i32.const -4 - i32.and - i32.add - local.tee $4 - i32.load - local.tee $2 - i32.const 1 - i32.and - if - local.get $0 - local.get $4 - call $~lib/rt/tlsf/removeBlock - local.get $1 - local.get $3 - i32.const 4 - i32.add - local.get $2 - i32.const -4 - i32.and - i32.add - local.tee $3 - i32.store - local.get $1 - i32.const 4 - i32.add - local.get $1 - i32.load - i32.const -4 - i32.and - i32.add - local.tee $4 - i32.load - local.set $2 - end - local.get $3 - i32.const 2 - i32.and - if - local.get $1 - i32.const 4 - i32.sub - i32.load - local.tee $1 - i32.load - local.tee $6 - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 221 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - call $~lib/rt/tlsf/removeBlock - local.get $1 - local.get $6 - i32.const 4 - i32.add - local.get $3 - i32.const -4 - i32.and - i32.add - local.tee $3 - i32.store - end - local.get $4 - local.get $2 - i32.const 2 - i32.or - i32.store - local.get $3 - i32.const -4 - i32.and - local.tee $2 - i32.const 12 - i32.lt_u - if - i32.const 0 - i32.const 1648 - i32.const 233 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $4 - local.get $1 - i32.const 4 - i32.add - local.get $2 - i32.add - i32.ne - if - i32.const 0 - i32.const 1648 - i32.const 234 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $4 - i32.const 4 - i32.sub - local.get $1 - i32.store - local.get $2 - i32.const 256 - i32.lt_u - if (result i32) - local.get $2 - i32.const 4 - i32.shr_u - else - i32.const 31 - i32.const 1073741820 - local.get $2 - local.get $2 - i32.const 1073741820 - i32.ge_u - select - local.tee $2 - i32.clz - i32.sub - local.tee $3 - i32.const 7 - i32.sub - local.set $5 - local.get $2 - local.get $3 - i32.const 4 - i32.sub - i32.shr_u - i32.const 16 - i32.xor - end - local.tee $2 - i32.const 16 - i32.lt_u - local.get $5 - i32.const 23 - i32.lt_u - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 251 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $5 - i32.const 4 - i32.shl - local.get $2 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - local.set $3 - local.get $1 - i32.const 0 - i32.store offset=4 - local.get $1 - local.get $3 - i32.store offset=8 - local.get $3 - if - local.get $3 - local.get $1 - i32.store offset=4 - end - local.get $0 - local.get $5 - i32.const 4 - i32.shl - local.get $2 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $1 - i32.store offset=96 - local.get $0 - local.get $0 - i32.load - i32.const 1 - local.get $5 - i32.shl - i32.or - i32.store - local.get $0 - local.get $5 - i32.const 2 - i32.shl - i32.add - local.tee $0 - local.get $0 - i32.load offset=4 - i32.const 1 - local.get $2 - i32.shl - i32.or - i32.store offset=4 - ) - (func $~lib/rt/tlsf/addMemory (param $0 i32) (param $1 i32) (param $2 i64) - (local $3 i32) - (local $4 i32) - (local $5 i32) - local.get $2 - local.get $1 - i64.extend_i32_u - i64.lt_u - if - i32.const 0 - i32.const 1648 - i32.const 382 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.const 19 - i32.add - i32.const -16 - i32.and - i32.const 4 - i32.sub - local.set $1 - local.get $0 - i32.load offset=1568 - local.tee $3 - if - local.get $3 - i32.const 4 - i32.add - local.get $1 - i32.gt_u - if - i32.const 0 - i32.const 1648 - i32.const 389 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $3 - local.get $1 - i32.const 16 - i32.sub - local.tee $5 - i32.eq - if - local.get $3 - i32.load - local.set $4 - local.get $5 - local.set $1 - end - else - local.get $0 - i32.const 1572 - i32.add - local.get $1 - i32.gt_u - if - i32.const 0 - i32.const 1648 - i32.const 402 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - end - local.get $2 - i32.wrap_i64 - i32.const -16 - i32.and - local.get $1 - i32.sub - local.tee $3 - i32.const 20 - i32.lt_u - if - return - end - local.get $1 - local.get $4 - i32.const 2 - i32.and - local.get $3 - i32.const 8 - i32.sub - local.tee $3 - i32.const 1 - i32.or - i32.or - i32.store - local.get $1 - i32.const 0 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=8 - local.get $1 - i32.const 4 - i32.add - local.get $3 - i32.add - local.tee $3 - i32.const 2 - i32.store - local.get $0 - local.get $3 - i32.store offset=1568 - local.get $0 - local.get $1 - call $~lib/rt/tlsf/insertBlock - ) - (func $~lib/rt/tlsf/initialize - (local $0 i32) - (local $1 i32) - memory.size - local.tee $1 - i32.const 0 - i32.le_s - if (result i32) - i32.const 1 - local.get $1 - i32.sub - memory.grow - i32.const 0 - i32.lt_s - else - i32.const 0 - end - if - unreachable - end - i32.const 54592 - i32.const 0 - i32.store - i32.const 56160 - i32.const 0 - i32.store - loop $for-loop|0 - local.get $0 - i32.const 23 - i32.lt_u - if - local.get $0 - i32.const 2 - i32.shl - i32.const 54592 - i32.add - i32.const 0 - i32.store offset=4 - i32.const 0 - local.set $1 - loop $for-loop|1 - local.get $1 - i32.const 16 - i32.lt_u - if - local.get $0 - i32.const 4 - i32.shl - local.get $1 - i32.add - i32.const 2 - i32.shl - i32.const 54592 - i32.add - i32.const 0 - i32.store offset=96 - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|1 - end - end - local.get $0 - i32.const 1 - i32.add - local.set $0 - br $for-loop|0 - end - end - i32.const 54592 - i32.const 56164 - memory.size - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - i32.const 54592 - global.set $~lib/rt/tlsf/ROOT - ) - (func $~lib/rt/itcms/step (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i32) - block $break|0 - block $case2|0 - block $case1|0 - block $case0|0 - global.get $~lib/rt/itcms/state - br_table $case0|0 $case1|0 $case2|0 $break|0 - end - i32.const 1 - global.set $~lib/rt/itcms/state - i32.const 0 - global.set $~lib/rt/itcms/visitCount - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/iter - global.get $~lib/rt/itcms/visitCount - return - end - global.get $~lib/rt/itcms/white - i32.eqz - local.set $1 - global.get $~lib/rt/itcms/iter - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - loop $while-continue|1 - local.get $0 - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $0 - global.set $~lib/rt/itcms/iter - local.get $1 - local.get $0 - i32.load offset=4 - local.tee $2 - i32.const 3 - i32.and - i32.ne - if - local.get $0 - local.get $2 - i32.const -4 - i32.and - local.get $1 - i32.or - i32.store offset=4 - i32.const 0 - global.set $~lib/rt/itcms/visitCount - local.get $0 - i32.const 20 - i32.add - call $~lib/rt/__visit_members - global.get $~lib/rt/itcms/visitCount - return - end - local.get $0 - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - br $while-continue|1 - end - end - i32.const 0 - global.set $~lib/rt/itcms/visitCount - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/iter - i32.load offset=4 - i32.const -4 - i32.and - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.set $0 - loop $while-continue|0 - local.get $0 - i32.const 54580 - i32.lt_u - if - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - local.get $0 - i32.const 4 - i32.add - local.set $0 - br $while-continue|0 - end - end - global.get $~lib/rt/itcms/iter - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - loop $while-continue|2 - local.get $0 - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $1 - local.get $0 - i32.load offset=4 - local.tee $2 - i32.const 3 - i32.and - i32.ne - if - local.get $0 - local.get $2 - i32.const -4 - i32.and - local.get $1 - i32.or - i32.store offset=4 - local.get $0 - i32.const 20 - i32.add - call $~lib/rt/__visit_members - end - local.get $0 - i32.load offset=4 - i32.const -4 - i32.and - local.set $0 - br $while-continue|2 - end - end - global.get $~lib/rt/itcms/fromSpace - local.set $0 - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/fromSpace - local.get $0 - global.set $~lib/rt/itcms/toSpace - local.get $1 - global.set $~lib/rt/itcms/white - local.get $0 - i32.load offset=4 - i32.const -4 - i32.and - global.set $~lib/rt/itcms/iter - i32.const 2 - global.set $~lib/rt/itcms/state - end - global.get $~lib/rt/itcms/visitCount - return - end - global.get $~lib/rt/itcms/iter - local.tee $0 - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $0 - i32.load offset=4 - local.tee $1 - i32.const -4 - i32.and - global.set $~lib/rt/itcms/iter - global.get $~lib/rt/itcms/white - i32.eqz - local.get $1 - i32.const 3 - i32.and - i32.ne - if - i32.const 0 - i32.const 1376 - i32.const 229 - i32.const 20 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.const 54580 - i32.lt_u - if - local.get $0 - i32.const 0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=8 - else - global.get $~lib/rt/itcms/total - local.get $0 - i32.load - i32.const -4 - i32.and - i32.const 4 - i32.add - i32.sub - global.set $~lib/rt/itcms/total - local.get $0 - i32.const 4 - i32.add - local.tee $0 - i32.const 54580 - i32.ge_u - if - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $0 - i32.const 4 - i32.sub - local.set $2 - local.get $0 - i32.const 15 - i32.and - i32.const 1 - local.get $0 - select - if (result i32) - i32.const 1 - else - local.get $2 - i32.load - i32.const 1 - i32.and - end - if - i32.const 0 - i32.const 1648 - i32.const 562 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - local.get $2 - local.get $2 - i32.load - i32.const 1 - i32.or - i32.store - local.get $2 - call $~lib/rt/tlsf/insertBlock - end - end - i32.const 10 - return - end - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - i32.store offset=4 - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - i32.store offset=8 - i32.const 0 - global.set $~lib/rt/itcms/state - end - i32.const 0 - ) - (func $~lib/rt/tlsf/searchBlock (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - local.get $1 - i32.const 256 - i32.lt_u - if - local.get $1 - i32.const 4 - i32.shr_u - local.set $1 - else - local.get $1 - i32.const 536870910 - i32.lt_u - if - local.get $1 - i32.const 1 - i32.const 27 - local.get $1 - i32.clz - i32.sub - i32.shl - i32.add - i32.const 1 - i32.sub - local.set $1 - end - local.get $1 - i32.const 31 - local.get $1 - i32.clz - i32.sub - local.tee $2 - i32.const 4 - i32.sub - i32.shr_u - i32.const 16 - i32.xor - local.set $1 - local.get $2 - i32.const 7 - i32.sub - local.set $2 - end - local.get $1 - i32.const 16 - i32.lt_u - local.get $2 - i32.const 23 - i32.lt_u - i32.and - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 334 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $2 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - i32.const -1 - local.get $1 - i32.shl - i32.and - local.tee $1 - if (result i32) - local.get $0 - local.get $1 - i32.ctz - local.get $2 - i32.const 4 - i32.shl - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - else - local.get $0 - i32.load - i32.const -1 - local.get $2 - i32.const 1 - i32.add - i32.shl - i32.and - local.tee $1 - if (result i32) - local.get $0 - local.get $1 - i32.ctz - local.tee $1 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - local.tee $2 - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 347 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $2 - i32.ctz - local.get $1 - i32.const 4 - i32.shl - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - else - i32.const 0 - end - end - ) - (func $~lib/rt/tlsf/allocateBlock (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - local.get $1 - i32.const 1073741820 - i32.gt_u - if - i32.const 1312 - i32.const 1648 - i32.const 461 - i32.const 29 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 12 - i32.le_u - if (result i32) - i32.const 12 - else - local.get $1 - i32.const 19 - i32.add - i32.const -16 - i32.and - i32.const 4 - i32.sub - end - local.tee $3 - call $~lib/rt/tlsf/searchBlock - local.tee $1 - i32.eqz - if - memory.size - local.tee $1 - local.get $3 - i32.const 256 - i32.ge_u - if (result i32) - local.get $3 - i32.const 536870910 - i32.lt_u - if (result i32) - local.get $3 - i32.const 1 - i32.const 27 - local.get $3 - i32.clz - i32.sub - i32.shl - i32.add - i32.const 1 - i32.sub - else - local.get $3 - end - else - local.get $3 - end - i32.const 4 - local.get $0 - i32.load offset=1568 - local.get $1 - i32.const 16 - i32.shl - i32.const 4 - i32.sub - i32.ne - i32.shl - i32.add - i32.const 65535 - i32.add - i32.const -65536 - i32.and - i32.const 16 - i32.shr_u - local.tee $2 - local.get $1 - local.get $2 - i32.gt_s - select - memory.grow - i32.const 0 - i32.lt_s - if - local.get $2 - memory.grow - i32.const 0 - i32.lt_s - if - unreachable - end - end - local.get $0 - local.get $1 - i32.const 16 - i32.shl - memory.size - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - local.get $0 - local.get $3 - call $~lib/rt/tlsf/searchBlock - local.tee $1 - i32.eqz - if - i32.const 0 - i32.const 1648 - i32.const 499 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - end - local.get $3 - local.get $1 - i32.load - i32.const -4 - i32.and - i32.gt_u - if - i32.const 0 - i32.const 1648 - i32.const 501 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - call $~lib/rt/tlsf/removeBlock - local.get $1 - i32.load - local.set $4 - local.get $3 - i32.const 4 - i32.add - i32.const 15 - i32.and - if - i32.const 0 - i32.const 1648 - i32.const 361 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $4 - i32.const -4 - i32.and - local.get $3 - i32.sub - local.tee $2 - i32.const 16 - i32.ge_u - if - local.get $1 - local.get $3 - local.get $4 - i32.const 2 - i32.and - i32.or - i32.store - local.get $1 - i32.const 4 - i32.add - local.get $3 - i32.add - local.tee $3 - local.get $2 - i32.const 4 - i32.sub - i32.const 1 - i32.or - i32.store - local.get $0 - local.get $3 - call $~lib/rt/tlsf/insertBlock - else - local.get $1 - local.get $4 - i32.const -2 - i32.and - i32.store - local.get $1 - i32.const 4 - i32.add - local.get $1 - i32.load - i32.const -4 - i32.and - i32.add - local.tee $0 - local.get $0 - i32.load - i32.const -3 - i32.and - i32.store - end - local.get $1 - ) - (func $~lib/rt/itcms/__new (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - local.get $0 - i32.const 1073741804 - i32.ge_u - if - i32.const 1312 - i32.const 1376 - i32.const 261 - i32.const 31 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.ge_u - if - block $__inlined_func$~lib/rt/itcms/interrupt$69 - i32.const 2048 - local.set $2 - loop $do-loop|0 - local.get $2 - call $~lib/rt/itcms/step - i32.sub - local.set $2 - global.get $~lib/rt/itcms/state - i32.eqz - if - global.get $~lib/rt/itcms/total - i64.extend_i32_u - i64.const 200 - i64.mul - i64.const 100 - i64.div_u - i32.wrap_i64 - i32.const 1024 - i32.add - global.set $~lib/rt/itcms/threshold - br $__inlined_func$~lib/rt/itcms/interrupt$69 - end - local.get $2 - i32.const 0 - i32.gt_s - br_if $do-loop|0 - end - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.sub - i32.const 1024 - i32.lt_u - i32.const 10 - i32.shl - i32.add - global.set $~lib/rt/itcms/threshold - end - end - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $0 - i32.const 16 - i32.add - call $~lib/rt/tlsf/allocateBlock - local.tee $2 - local.get $1 - i32.store offset=12 - local.get $2 - local.get $0 - i32.store offset=16 - global.get $~lib/rt/itcms/fromSpace - local.tee $1 - i32.load offset=8 - local.set $3 - local.get $2 - local.get $1 - global.get $~lib/rt/itcms/white - i32.or - i32.store offset=4 - local.get $2 - local.get $3 - i32.store offset=8 - local.get $3 - local.get $2 - local.get $3 - i32.load offset=4 - i32.const 3 - i32.and - i32.or - i32.store offset=4 - local.get $1 - local.get $2 - i32.store offset=8 - global.get $~lib/rt/itcms/total - local.get $2 - i32.load - i32.const -4 - i32.and - i32.const 4 - i32.add - i32.add - global.set $~lib/rt/itcms/total - local.get $2 - i32.const 20 - i32.add - local.tee $1 - i32.const 0 - local.get $0 - memory.fill - local.get $1 - ) - (func $start:assembly/arguments~anonymous|0 (param $0 i32) (param $1 i32) (result i32) - i32.const 0 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - ) - (func $~lib/rt/itcms/__link (param $0 i32) (param $1 i32) (param $2 i32) - (local $3 i32) - local.get $1 - i32.eqz - if - return - end - local.get $0 - i32.eqz - if - i32.const 0 - i32.const 1376 - i32.const 295 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/white - local.get $1 - i32.const 20 - i32.sub - local.tee $1 - i32.load offset=4 - i32.const 3 - i32.and - i32.eq - if - local.get $0 - i32.const 20 - i32.sub - local.tee $0 - i32.load offset=4 - i32.const 3 - i32.and - local.tee $3 - global.get $~lib/rt/itcms/white - i32.eqz - i32.eq - if - local.get $0 - local.get $1 - local.get $2 - select - call $~lib/rt/itcms/Object#makeGray - else - global.get $~lib/rt/itcms/state - i32.const 1 - i32.eq - local.get $3 - i32.const 3 - i32.eq - i32.and - if - local.get $1 - call $~lib/rt/itcms/Object#makeGray - end - end - end - ) - (func $assembly/instructions/instruction (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - i32.const 17 - call $~lib/rt/tlsf/allocateBlock - i32.const 4 - i32.add - local.tee $3 - i32.const 0 - i32.store - local.get $3 - i32.const 0 - i32.store offset=4 - local.get $3 - i64.const 0 - i64.store offset=8 - local.get $3 - i32.const 0 - i32.store8 offset=16 - local.get $3 - local.get $0 - i32.store - local.get $3 - local.get $1 - i32.store offset=4 - local.get $3 - i64.const 1 - i64.store offset=8 - local.get $3 - local.get $2 - i32.store8 offset=16 - local.get $3 - ) - (func $start:assembly/instructions/misc~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $start:assembly/instructions/misc~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - call $assembly/instructions/outcome/OutcomeData#constructor - ) - (func $~lib/util/number/utoa32_dec_lut (param $0 i32) (param $1 i32) (param $2 i32) - (local $3 i32) - loop $while-continue|0 - local.get $1 - i32.const 10000 - i32.ge_u - if - local.get $1 - i32.const 10000 - i32.rem_u - local.set $3 - local.get $1 - i32.const 10000 - i32.div_u - local.set $1 - local.get $0 - local.get $2 - i32.const 4 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $3 - i32.const 100 - i32.div_u - i32.const 2 - i32.shl - i32.const 16092 - i32.add - i64.load32_u - local.get $3 - i32.const 100 - i32.rem_u - i32.const 2 - i32.shl - i32.const 16092 - i32.add - i64.load32_u - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $1 - i32.const 100 - i32.ge_u - if - local.get $0 - local.get $2 - i32.const 2 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $1 - i32.const 100 - i32.rem_u - i32.const 2 - i32.shl - i32.const 16092 - i32.add - i32.load - i32.store - local.get $1 - i32.const 100 - i32.div_u - local.set $1 - end - local.get $1 - i32.const 10 - i32.ge_u - if - local.get $0 - local.get $2 - i32.const 2 - i32.sub - i32.const 1 - i32.shl - i32.add - local.get $1 - i32.const 2 - i32.shl - i32.const 16092 - i32.add - i32.load - i32.store - else - local.get $0 - local.get $2 - i32.const 1 - i32.sub - i32.const 1 - i32.shl - i32.add - local.get $1 - i32.const 48 - i32.add - i32.store16 - end - ) - (func $~lib/util/number/utoa64_any_core (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) - (local $4 i64) - (local $5 i64) - local.get $3 - i64.extend_i32_s - local.set $5 - local.get $3 - local.get $3 - i32.const 1 - i32.sub - i32.and - if - loop $do-loop|1 - local.get $0 - local.get $2 - i32.const 1 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $1 - local.get $1 - local.get $5 - i64.div_u - local.tee $1 - local.get $5 - i64.mul - i64.sub - i32.wrap_i64 - i32.const 1 - i32.shl - i32.const 17568 - i32.add - i32.load16_u - i32.store16 - local.get $1 - i64.const 0 - i64.ne - br_if $do-loop|1 - end - else - local.get $3 - i32.ctz - i32.const 7 - i32.and - i64.extend_i32_s - local.set $4 - local.get $5 - i64.const 1 - i64.sub - local.set $5 - loop $do-loop|0 - local.get $0 - local.get $2 - i32.const 1 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $1 - local.get $5 - i64.and - i32.wrap_i64 - i32.const 1 - i32.shl - i32.const 17568 - i32.add - i32.load16_u - i32.store16 - local.get $1 - local.get $4 - i64.shr_u - local.tee $1 - i64.const 0 - i64.ne - br_if $do-loop|0 - end - end - ) - (func $~lib/number/I32#toString (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $__inlined_func$~lib/util/number/itoa32$100 - local.get $0 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 16080 - local.set $0 - br $__inlined_func$~lib/util/number/itoa32$100 - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $0 - i32.sub - local.get $0 - local.get $0 - i32.const 31 - i32.shr_u - i32.const 1 - i32.shl - local.tee $1 - select - local.tee $3 - i32.const 100000 - i32.lt_u - if (result i32) - local.get $3 - i32.const 100 - i32.lt_u - if (result i32) - local.get $3 - i32.const 10 - i32.ge_u - i32.const 1 - i32.add - else - local.get $3 - i32.const 10000 - i32.ge_u - i32.const 3 - i32.add - local.get $3 - i32.const 1000 - i32.ge_u - i32.add - end - else - local.get $3 - i32.const 10000000 - i32.lt_u - if (result i32) - local.get $3 - i32.const 1000000 - i32.ge_u - i32.const 6 - i32.add - else - local.get $3 - i32.const 1000000000 - i32.ge_u - i32.const 8 - i32.add - local.get $3 - i32.const 100000000 - i32.ge_u - i32.add - end - end - local.tee $2 - i32.const 1 - i32.shl - local.get $1 - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - local.get $0 - local.get $1 - i32.add - local.get $3 - local.get $2 - call $~lib/util/number/utoa32_dec_lut - local.get $1 - if - local.get $0 - i32.const 45 - i32.store16 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - end - local.get $0 - ) - (func $~lib/util/number/utoa64_dec_lut (param $0 i32) (param $1 i64) (param $2 i32) - (local $3 i32) - (local $4 i32) - loop $while-continue|0 - local.get $1 - i64.const 100000000 - i64.ge_u - if - local.get $0 - local.get $2 - i32.const 4 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $1 - local.get $1 - i64.const 100000000 - i64.div_u - local.tee $1 - i64.const 100000000 - i64.mul - i64.sub - i32.wrap_i64 - local.tee $3 - i32.const 10000 - i32.rem_u - local.tee $4 - i32.const 100 - i32.div_u - i32.const 2 - i32.shl - i32.const 16092 - i32.add - i64.load32_u - local.get $4 - i32.const 100 - i32.rem_u - i32.const 2 - i32.shl - i32.const 16092 - i32.add - i64.load32_u - i64.const 32 - i64.shl - i64.or - i64.store - local.get $0 - local.get $2 - i32.const 4 - i32.sub - local.tee $2 - i32.const 1 - i32.shl - i32.add - local.get $3 - i32.const 10000 - i32.div_u - local.tee $3 - i32.const 100 - i32.div_u - i32.const 2 - i32.shl - i32.const 16092 - i32.add - i64.load32_u - local.get $3 - i32.const 100 - i32.rem_u - i32.const 2 - i32.shl - i32.const 16092 - i32.add - i64.load32_u - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $0 - local.get $1 - i32.wrap_i64 - local.get $2 - call $~lib/util/number/utoa32_dec_lut - ) - (func $~lib/util/number/itoa_buffered (param $0 i32) (param $1 i64) (result i32) - (local $2 i32) - (local $3 i32) - local.get $0 - local.set $2 - local.get $1 - i64.const 10 - i64.lt_u - if - local.get $0 - local.get $1 - i64.const 48 - i64.or - i64.store16 - i32.const 1 - return - end - local.get $1 - i64.const 4294967295 - i64.le_u - if - local.get $1 - i32.wrap_i64 - local.tee $3 - i32.const 100000 - i32.lt_u - if (result i32) - local.get $3 - i32.const 100 - i32.lt_u - if (result i32) - local.get $3 - i32.const 10 - i32.ge_u - i32.const 1 - i32.add - else - local.get $3 - i32.const 10000 - i32.ge_u - i32.const 3 - i32.add - local.get $3 - i32.const 1000 - i32.ge_u - i32.add - end - else - local.get $3 - i32.const 10000000 - i32.lt_u - if (result i32) - local.get $3 - i32.const 1000000 - i32.ge_u - i32.const 6 - i32.add - else - local.get $3 - i32.const 1000000000 - i32.ge_u - i32.const 8 - i32.add - local.get $3 - i32.const 100000000 - i32.ge_u - i32.add - end - end - local.set $0 - local.get $2 - local.get $3 - local.get $0 - call $~lib/util/number/utoa32_dec_lut - else - local.get $2 - local.get $1 - local.get $1 - i64.const 1000000000000000 - i64.lt_u - if (result i32) - local.get $1 - i64.const 1000000000000 - i64.lt_u - if (result i32) - local.get $1 - i64.const 100000000000 - i64.ge_u - i32.const 10 - i32.add - local.get $1 - i64.const 10000000000 - i64.ge_u - i32.add - else - local.get $1 - i64.const 100000000000000 - i64.ge_u - i32.const 13 - i32.add - local.get $1 - i64.const 10000000000000 - i64.ge_u - i32.add - end - else - local.get $1 - i64.const 100000000000000000 - i64.lt_u - if (result i32) - local.get $1 - i64.const 10000000000000000 - i64.ge_u - i32.const 16 - i32.add - else - local.get $1 - i64.const -8446744073709551616 - i64.ge_u - i32.const 18 - i32.add - local.get $1 - i64.const 1000000000000000000 - i64.ge_u - i32.add - end - end - local.tee $0 - call $~lib/util/number/utoa64_dec_lut - end - local.get $0 - ) - (func $~lib/rt/itcms/__pin (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - local.get $0 - if - local.get $0 - i32.const 20 - i32.sub - local.tee $1 - i32.load offset=4 - i32.const 3 - i32.and - i32.const 3 - i32.eq - if - i32.const 21440 - i32.const 1376 - i32.const 338 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $1 - call $~lib/rt/itcms/Object#unlink - global.get $~lib/rt/itcms/pinSpace - local.tee $3 - i32.load offset=8 - local.set $2 - local.get $1 - local.get $3 - i32.const 3 - i32.or - i32.store offset=4 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $2 - local.get $1 - local.get $2 - i32.load offset=4 - i32.const 3 - i32.and - i32.or - i32.store offset=4 - local.get $3 - local.get $1 - i32.store offset=8 - end - local.get $0 - ) - (func $~lib/rt/itcms/__unpin (param $0 i32) - (local $1 i32) - (local $2 i32) - local.get $0 - i32.eqz - if - return - end - local.get $0 - i32.const 20 - i32.sub - local.tee $1 - i32.load offset=4 - i32.const 3 - i32.and - i32.const 3 - i32.ne - if - i32.const 21504 - i32.const 1376 - i32.const 352 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/state - i32.const 1 - i32.eq - if - local.get $1 - call $~lib/rt/itcms/Object#makeGray - else - local.get $1 - call $~lib/rt/itcms/Object#unlink - global.get $~lib/rt/itcms/fromSpace - local.tee $0 - i32.load offset=8 - local.set $2 - local.get $1 - local.get $0 - global.get $~lib/rt/itcms/white - i32.or - i32.store offset=4 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $2 - local.get $1 - local.get $2 - i32.load offset=4 - i32.const 3 - i32.and - i32.or - i32.store offset=4 - local.get $0 - local.get $1 - i32.store offset=8 - end - ) - (func $~lib/rt/itcms/__collect - global.get $~lib/rt/itcms/state - i32.const 0 - i32.gt_s - if - loop $while-continue|0 - global.get $~lib/rt/itcms/state - if - call $~lib/rt/itcms/step - drop - br $while-continue|0 - end - end - end - call $~lib/rt/itcms/step - drop - loop $while-continue|1 - global.get $~lib/rt/itcms/state - if - call $~lib/rt/itcms/step - drop - br $while-continue|1 - end - end - global.get $~lib/rt/itcms/total - i64.extend_i32_u - i64.const 200 - i64.mul - i64.const 100 - i64.div_u - i32.wrap_i64 - i32.const 1024 - i32.add - global.set $~lib/rt/itcms/threshold - ) - (func $assembly/gas/GasCounter#set@override (param $0 i32) (param $1 i64) - local.get $0 - i32.const 8 - i32.sub - i32.load - i32.const 46 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - unreachable - ) - (func $assembly/gas/GasCounter#sub@override (param $0 i32) (param $1 i64) (result i32) - local.get $0 - i32.const 8 - i32.sub - i32.load - i32.const 46 - i32.eq - if - block $__inlined_func$assembly/gas/GasCounterU64#sub$106 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i64.load - local.get $1 - i64.sub - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load - i64.const 0 - i64.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 1 - br $__inlined_func$assembly/gas/GasCounterU64#sub$106 - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - end - return - end - unreachable - ) - (func $assembly/gas/GasCounter#get@override (param $0 i32) (result i64) - (local $1 i64) - local.get $0 - i32.const 8 - i32.sub - i32.load - i32.const 46 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - unreachable - ) - (func $"~lib/map/Map~visit" (param $0 i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - local.tee $2 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=16 - i32.const 12 - i32.mul - i32.add - local.set $0 - loop $while-continue|0 - local.get $0 - local.get $1 - i32.gt_u - if - local.get $1 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - local.get $1 - i32.load offset=4 - call $~lib/rt/itcms/__visit - end - local.get $1 - i32.const 12 - i32.add - local.set $1 - br $while-continue|0 - end - end - local.get $2 - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/interpreter/Interpreter~visit (param $0 i32) - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - call $~lib/rt/itcms/__visit - ) - (func $~lib/rt/__visit_members (param $0 i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - block $folding-inner9 - block $folding-inner8 - block $folding-inner7 - block $folding-inner6 - block $folding-inner5 - block $folding-inner4 - block $folding-inner3 - block $folding-inner2 - block $folding-inner1 - block $folding-inner0 - block $invalid - block $assembly/program/ResolvedArguments - block $assembly/api-internal/VmOutput - block $"~lib/map/Map" - block $assembly/gas-costs/BlockGasCost - block $assembly/interpreter/BranchResult - block $assembly/interpreter/DjumpResult - block $assembly/api-internal/InitialPage - block $assembly/gas/GasCounterU64 - block $assembly/spi/StandardProgram - block $assembly/codec/ValOffset - block $~lib/staticarray/StaticArray - block $~lib/staticarray/StaticArray<~lib/string/String> - block $assembly/gas/GasCounter - block $~lib/staticarray/StaticArray - block $~lib/staticarray/StaticArray - block $assembly/program/Program - block $assembly/interpreter/Interpreter - block $assembly/memory/Chunks - block $~lib/staticarray/StaticArray - block $assembly/memory/Result - block $assembly/instructions/outcome/OutcomeData - block $"~lib/map/Map" - block $~lib/staticarray/StaticArray - block $assembly/memory/MaybePageFault - block $assembly/arguments/Nibbles - block $assembly/arguments/Args - block $~lib/string/String - block $~lib/arraybuffer/ArrayBuffer - block $~lib/object/Object - local.get $0 - i32.const 8 - i32.sub - i32.load - br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $folding-inner4 $folding-inner0 $folding-inner4 $assembly/arguments/Args $folding-inner1 $folding-inner2 $assembly/arguments/Nibbles $folding-inner0 $assembly/memory/MaybePageFault $folding-inner5 $folding-inner5 $~lib/staticarray/StaticArray $folding-inner6 $folding-inner4 $folding-inner1 $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $folding-inner2 $assembly/memory/Result $folding-inner3 $~lib/staticarray/StaticArray $assembly/memory/Chunks $folding-inner3 $folding-inner1 $folding-inner0 $folding-inner2 $assembly/interpreter/Interpreter $assembly/program/Program $folding-inner4 $~lib/staticarray/StaticArray $folding-inner4 $folding-inner4 $~lib/staticarray/StaticArray $assembly/gas/GasCounter $~lib/staticarray/StaticArray<~lib/string/String> $folding-inner0 $~lib/staticarray/StaticArray $folding-inner4 $folding-inner3 $folding-inner4 $assembly/codec/ValOffset $assembly/spi/StandardProgram $folding-inner3 $assembly/gas/GasCounterU64 $folding-inner1 $assembly/api-internal/InitialPage $folding-inner1 $folding-inner5 $folding-inner1 $assembly/interpreter/DjumpResult $assembly/interpreter/BranchResult $assembly/gas-costs/BlockGasCost $folding-inner1 $folding-inner0 $"~lib/map/Map" $folding-inner2 $assembly/api-internal/VmOutput $folding-inner7 $folding-inner1 $folding-inner2 $assembly/program/ResolvedArguments $invalid - end - return - end - return - end - return - end - return - end - return - end - return - end - return - end - local.get $0 - call $"~lib/map/Map~visit" - return - end - return - end - local.get $0 - i32.load offset=8 - call $~lib/rt/itcms/__visit - return - end - return - end - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - br $folding-inner6 - end - local.get $0 - call $assembly/interpreter/Interpreter~visit - return - end - local.get $0 - call $assembly/interpreter/Interpreter~visit - return - end - return - end - return - end - return - end - local.get $0 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.add - local.set $1 - loop $while-continue|0 - local.get $0 - local.get $1 - i32.lt_u - if - local.get $0 - i32.load - local.tee $2 - if - local.get $2 - call $~lib/rt/itcms/__visit - end - local.get $0 - i32.const 4 - i32.add - local.set $0 - br $while-continue|0 - end - end - return - end - return - end - return - end - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - br $folding-inner7 - end - return - end - return - end - return - end - return - end - return - end - local.get $0 - call $"~lib/map/Map~visit" - return - end - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - call $~lib/rt/itcms/__visit - return - end - local.get $0 - i32.load offset=32 - call $~lib/rt/itcms/__visit - return - end - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - br $folding-inner9 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.const 2 - i32.shl - i32.add - local.set $3 - loop $while-continue|00 - local.get $1 - local.get $3 - i32.lt_u - if - local.get $1 - i32.load - local.tee $2 - if - local.get $2 - call $~lib/rt/itcms/__visit - end - local.get $1 - i32.const 4 - i32.add - local.set $1 - br $while-continue|00 - end - end - br $folding-inner9 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - return - end - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - return - end - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - return - end - local.get $0 - i32.load offset=4 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - call $~lib/rt/itcms/__visit - return - end - local.get $0 - i32.load offset=16 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=20 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=24 - call $~lib/rt/itcms/__visit - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~setArgumentsLength (param $0 i32) - local.get $0 - global.set $~argumentsLength - ) - (func $~start - (local $0 i32) - memory.size - i32.const 16 - i32.shl - i32.const 54580 - i32.sub - i32.const 1 - i32.shr_u - global.set $~lib/rt/itcms/threshold - i32.const 1428 - i32.const 1424 - i32.store - i32.const 1432 - i32.const 1424 - i32.store - i32.const 1424 - global.set $~lib/rt/itcms/pinSpace - i32.const 1460 - i32.const 1456 - i32.store - i32.const 1464 - i32.const 1456 - i32.store - i32.const 1456 - global.set $~lib/rt/itcms/toSpace - i32.const 1604 - i32.const 1600 - i32.store - i32.const 1608 - i32.const 1600 - i32.store - i32.const 1600 - global.set $~lib/rt/itcms/fromSpace - call $start:assembly/instructions - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - call $assembly/memory/MaybePageFault#constructor - global.set $assembly/memory/NO_PAGE_FAULT - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - global.set $assembly/memory/EMPTY_UINT8ARRAY - i32.const -1 - i32.const 0 - call $assembly/memory-page/RawPage#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 0 - local.get $0 - call $assembly/memory-page/Page#constructor - global.set $assembly/memory/EMPTY_PAGE - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/arguments/Args#constructor (result i32) - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 6 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/arguments/Args.from (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/arguments/Args#constructor - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#get:length (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#subarray (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $4 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $4 - local.get $0 - i32.load - local.tee $5 - i32.store - local.get $4 - local.get $5 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $4 - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 0 - i32.lt_s - if (result i32) - local.get $1 - local.get $3 - i32.add - local.tee $0 - i32.const 0 - local.get $0 - i32.const 0 - i32.gt_s - select - else - local.get $1 - local.get $3 - local.get $1 - local.get $3 - i32.lt_s - select - end - local.tee $0 - i32.add - i32.store offset=4 - local.get $4 - local.get $2 - i32.const 0 - i32.lt_s - if (result i32) - local.get $2 - local.get $3 - i32.add - local.tee $1 - i32.const 0 - local.get $1 - i32.const 0 - i32.gt_s - select - else - local.get $2 - local.get $3 - local.get $2 - local.get $3 - i32.lt_s - select - end - local.tee $1 - local.get $0 - local.get $0 - local.get $1 - i32.lt_s - select - local.get $0 - i32.sub - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=8 - i32.ge_u - if - i32.const 1504 - i32.const 1744 - i32.const 167 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - i32.load8_u - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/arguments/decodeI32 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - local.get $2 - local.get $1 - local.get $1 - local.get $2 - i32.lt_u - select - call $~lib/typedarray/Uint8Array#subarray - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_u - local.set $2 - i32.const 0 - local.set $1 - loop $for-loop|0 - local.get $2 - local.get $3 - i32.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - local.get $3 - i32.const 3 - i32.shl - i32.shl - i32.or - local.set $1 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - i32.const 255 - i32.const 0 - local.get $2 - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $2 - i32.const 1 - i32.sub - call $~lib/typedarray/Uint8Array#__get - i32.const 128 - i32.and - else - i32.const 0 - end - select - local.set $0 - loop $for-loop|1 - local.get $2 - i32.const 4 - i32.lt_u - if - local.get $1 - local.get $0 - local.get $2 - i32.const 3 - i32.shl - i32.shl - i32.or - local.set $1 - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/arguments~anonymous|1 (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - local.get $1 - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/arguments/nibbles (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 2 - i32.const 9 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - call $~lib/object/Object#constructor - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store8 offset=1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.const 15 - i32.and - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.const 255 - i32.and - i32.const 4 - i32.shr_u - i32.store8 offset=1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/arguments/twoImm (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u - f64.convert_i32_u - f64.const 4 - f64.min - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - local.get $2 - call $assembly/arguments/decodeI32 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $2 - local.get $1 - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|2 (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - call $assembly/arguments/twoImm - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|4 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - local.get $1 - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#subarray@varargs (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $1 - end - i32.const 2147483647 - local.set $2 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - call $~lib/typedarray/Uint8Array#subarray - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/arguments/decodeU32 (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 2 - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 3 - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|5 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load8_u - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - local.get $0 - i32.const 1 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/arguments/decodeU32 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - local.get $0 - i32.const 5 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/arguments/decodeU32 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|6 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u offset=1 - f64.convert_i32_u - f64.const 4 - f64.min - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - local.get $3 - call $assembly/arguments/decodeI32 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - local.get $1 - call $assembly/arguments/decodeI32 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u - local.get $4 - local.get $0 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|8 (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u offset=1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|9 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load8_u offset=1 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load8_u - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - local.get $1 - call $assembly/arguments/decodeI32 - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|11 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 1 - global.set $~argumentsLength - local.get $0 - i32.const 1 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.const 1 - i32.sub - i32.const 0 - local.get $1 - i32.const 1 - i32.gt_u - select - call $assembly/arguments/twoImm - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u offset=1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load8_u - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/arguments~anonymous|12 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load8_u offset=1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load8_u - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u - i32.const 0 - call $assembly/arguments/Args.from - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/ensureCapacity (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=8 - local.tee $5 - local.get $2 - i32.shr_u - i32.gt_u - if - local.get $1 - i32.const 1073741820 - local.get $2 - i32.shr_u - i32.gt_u - if - i32.const 9200 - i32.const 9152 - i32.const 19 - i32.const 48 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $4 - i32.const 8 - local.get $1 - local.get $1 - i32.const 8 - i32.le_u - select - local.get $2 - i32.shl - local.set $1 - local.get $3 - if - i32.const 1073741820 - local.get $5 - i32.const 1 - i32.shl - local.tee $2 - local.get $2 - i32.const 1073741820 - i32.ge_u - select - local.tee $2 - local.get $1 - local.get $1 - local.get $2 - i32.lt_u - select - local.set $1 - end - block $__inlined_func$~lib/rt/itcms/__renew$2450 - local.get $4 - i32.const 20 - i32.sub - local.tee $3 - i32.load - i32.const -4 - i32.and - i32.const 16 - i32.sub - local.get $1 - i32.ge_u - if - local.get $3 - local.get $1 - i32.store offset=16 - local.get $4 - local.set $2 - br $__inlined_func$~lib/rt/itcms/__renew$2450 - end - local.get $1 - local.get $3 - i32.load offset=12 - call $~lib/rt/itcms/__new - local.tee $2 - local.get $4 - local.get $1 - local.get $3 - i32.load offset=16 - local.tee $3 - local.get $1 - local.get $3 - i32.lt_u - select - memory.copy - end - local.get $2 - local.get $4 - i32.ne - if - local.get $0 - local.get $2 - i32.store - local.get $0 - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - end - local.get $0 - local.get $1 - i32.store offset=8 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__set (param $0 i32) (param $1 i32) (param $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - local.get $1 - i32.const 0 - i32.lt_s - if - i32.const 1504 - i32.const 9152 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - i32.store offset=12 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 2320 - i32.store - i32.const 2320 - i32.const 0 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/MISSING_INSTRUCTION - global.get $~lib/memory/__stack_pointer - i32.const 2368 - i32.store - i32.const 2368 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/SBRK - global.get $~lib/memory/__stack_pointer - i32.const 231 - i32.const 2 - i32.const 10 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 2400 - i32.store - local.get $0 - i32.const 0 - i32.const 2400 - i32.const 0 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2432 - i32.store - local.get $0 - i32.const 1 - i32.const 2432 - i32.const 0 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 5 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 6 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 7 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 8 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 9 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2480 - i32.store - local.get $0 - i32.const 10 - i32.const 2480 - i32.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 11 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 12 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 13 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 14 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 15 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 16 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 17 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 18 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 19 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2512 - i32.store - local.get $0 - i32.const 20 - i32.const 2512 - i32.const 5 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 21 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 22 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 23 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 24 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 25 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 26 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 27 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 28 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 29 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2560 - i32.store - local.get $0 - i32.const 30 - i32.const 2560 - i32.const 2 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2608 - i32.store - local.get $0 - i32.const 31 - i32.const 2608 - i32.const 2 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2656 - i32.store - local.get $0 - i32.const 32 - i32.const 2656 - i32.const 2 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2704 - i32.store - local.get $0 - i32.const 33 - i32.const 2704 - i32.const 2 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 34 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 35 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 36 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 37 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 38 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 39 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2752 - i32.store - local.get $0 - i32.const 40 - i32.const 2752 - i32.const 3 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 41 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 42 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 43 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 44 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 45 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 46 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 47 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 48 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 49 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2784 - i32.store - local.get $0 - i32.const 50 - i32.const 2784 - i32.const 4 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2832 - i32.store - local.get $0 - i32.const 51 - i32.const 2832 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2880 - i32.store - local.get $0 - i32.const 52 - i32.const 2880 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2928 - i32.store - local.get $0 - i32.const 53 - i32.const 2928 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 2976 - i32.store - local.get $0 - i32.const 54 - i32.const 2976 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3024 - i32.store - local.get $0 - i32.const 55 - i32.const 3024 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3072 - i32.store - local.get $0 - i32.const 56 - i32.const 3072 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3120 - i32.store - local.get $0 - i32.const 57 - i32.const 3120 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3168 - i32.store - local.get $0 - i32.const 58 - i32.const 3168 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3216 - i32.store - local.get $0 - i32.const 59 - i32.const 3216 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3264 - i32.store - local.get $0 - i32.const 60 - i32.const 3264 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3312 - i32.store - local.get $0 - i32.const 61 - i32.const 3312 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3360 - i32.store - local.get $0 - i32.const 62 - i32.const 3360 - i32.const 4 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 63 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 64 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 65 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 66 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 67 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 68 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 69 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3408 - i32.store - local.get $0 - i32.const 70 - i32.const 3408 - i32.const 6 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3472 - i32.store - local.get $0 - i32.const 71 - i32.const 3472 - i32.const 6 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3536 - i32.store - local.get $0 - i32.const 72 - i32.const 3536 - i32.const 6 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3600 - i32.store - local.get $0 - i32.const 73 - i32.const 3600 - i32.const 6 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 74 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 75 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 76 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 77 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 78 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 79 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3664 - i32.store - local.get $0 - i32.const 80 - i32.const 3664 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3712 - i32.store - local.get $0 - i32.const 81 - i32.const 3712 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3760 - i32.store - local.get $0 - i32.const 82 - i32.const 3760 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3808 - i32.store - local.get $0 - i32.const 83 - i32.const 3808 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3872 - i32.store - local.get $0 - i32.const 84 - i32.const 3872 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 3936 - i32.store - local.get $0 - i32.const 85 - i32.const 3936 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4000 - i32.store - local.get $0 - i32.const 86 - i32.const 4000 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4064 - i32.store - local.get $0 - i32.const 87 - i32.const 4064 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4128 - i32.store - local.get $0 - i32.const 88 - i32.const 4128 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4192 - i32.store - local.get $0 - i32.const 89 - i32.const 4192 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4256 - i32.store - local.get $0 - i32.const 90 - i32.const 4256 - i32.const 7 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 91 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 92 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 93 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 94 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 95 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 96 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 97 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 98 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 99 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4320 - i32.store - local.get $0 - i32.const 100 - i32.const 4320 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 101 - global.get $assembly/instructions/SBRK - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4368 - i32.store - local.get $0 - i32.const 102 - i32.const 4368 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4432 - i32.store - local.get $0 - i32.const 103 - i32.const 4432 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4496 - i32.store - local.get $0 - i32.const 104 - i32.const 4496 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4560 - i32.store - local.get $0 - i32.const 105 - i32.const 4560 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4624 - i32.store - local.get $0 - i32.const 106 - i32.const 4624 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4688 - i32.store - local.get $0 - i32.const 107 - i32.const 4688 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4752 - i32.store - local.get $0 - i32.const 108 - i32.const 4752 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4800 - i32.store - local.get $0 - i32.const 109 - i32.const 4800 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4848 - i32.store - local.get $0 - i32.const 110 - i32.const 4848 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4896 - i32.store - local.get $0 - i32.const 111 - i32.const 4896 - i32.const 8 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 112 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 113 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 114 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 115 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 116 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 117 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 118 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 119 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4944 - i32.store - local.get $0 - i32.const 120 - i32.const 4944 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 4992 - i32.store - local.get $0 - i32.const 121 - i32.const 4992 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5040 - i32.store - local.get $0 - i32.const 122 - i32.const 5040 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5088 - i32.store - local.get $0 - i32.const 123 - i32.const 5088 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5136 - i32.store - local.get $0 - i32.const 124 - i32.const 5136 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5184 - i32.store - local.get $0 - i32.const 125 - i32.const 5184 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5232 - i32.store - local.get $0 - i32.const 126 - i32.const 5232 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5280 - i32.store - local.get $0 - i32.const 127 - i32.const 5280 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5328 - i32.store - local.get $0 - i32.const 128 - i32.const 5328 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5376 - i32.store - local.get $0 - i32.const 129 - i32.const 5376 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5424 - i32.store - local.get $0 - i32.const 130 - i32.const 5424 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5472 - i32.store - local.get $0 - i32.const 131 - i32.const 5472 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5520 - i32.store - local.get $0 - i32.const 132 - i32.const 5520 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5568 - i32.store - local.get $0 - i32.const 133 - i32.const 5568 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5616 - i32.store - local.get $0 - i32.const 134 - i32.const 5616 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5648 - i32.store - local.get $0 - i32.const 135 - i32.const 5648 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5696 - i32.store - local.get $0 - i32.const 136 - i32.const 5696 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5744 - i32.store - local.get $0 - i32.const 137 - i32.const 5744 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5792 - i32.store - local.get $0 - i32.const 138 - i32.const 5792 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5840 - i32.store - local.get $0 - i32.const 139 - i32.const 5840 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5888 - i32.store - local.get $0 - i32.const 140 - i32.const 5888 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5936 - i32.store - local.get $0 - i32.const 141 - i32.const 5936 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 5984 - i32.store - local.get $0 - i32.const 142 - i32.const 5984 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6032 - i32.store - local.get $0 - i32.const 143 - i32.const 6032 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6080 - i32.store - local.get $0 - i32.const 144 - i32.const 6080 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6144 - i32.store - local.get $0 - i32.const 145 - i32.const 6144 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6208 - i32.store - local.get $0 - i32.const 146 - i32.const 6208 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6272 - i32.store - local.get $0 - i32.const 147 - i32.const 6272 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6320 - i32.store - local.get $0 - i32.const 148 - i32.const 6320 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6368 - i32.store - local.get $0 - i32.const 149 - i32.const 6368 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6416 - i32.store - local.get $0 - i32.const 150 - i32.const 6416 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6464 - i32.store - local.get $0 - i32.const 151 - i32.const 6464 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6512 - i32.store - local.get $0 - i32.const 152 - i32.const 6512 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6560 - i32.store - local.get $0 - i32.const 153 - i32.const 6560 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6608 - i32.store - local.get $0 - i32.const 154 - i32.const 6608 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6656 - i32.store - local.get $0 - i32.const 155 - i32.const 6656 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6720 - i32.store - local.get $0 - i32.const 156 - i32.const 6720 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6784 - i32.store - local.get $0 - i32.const 157 - i32.const 6784 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6848 - i32.store - local.get $0 - i32.const 158 - i32.const 6848 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6896 - i32.store - local.get $0 - i32.const 159 - i32.const 6896 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 6960 - i32.store - local.get $0 - i32.const 160 - i32.const 6960 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7008 - i32.store - local.get $0 - i32.const 161 - i32.const 7008 - i32.const 9 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 162 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 163 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 164 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 165 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 166 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 167 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 168 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 169 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7072 - i32.store - local.get $0 - i32.const 170 - i32.const 7072 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7120 - i32.store - local.get $0 - i32.const 171 - i32.const 7120 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7168 - i32.store - local.get $0 - i32.const 172 - i32.const 7168 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7216 - i32.store - local.get $0 - i32.const 173 - i32.const 7216 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7264 - i32.store - local.get $0 - i32.const 174 - i32.const 7264 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7312 - i32.store - local.get $0 - i32.const 175 - i32.const 7312 - i32.const 10 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 176 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 177 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 178 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 179 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7360 - i32.store - local.get $0 - i32.const 180 - i32.const 7360 - i32.const 11 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 181 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 182 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 183 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 184 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 185 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 186 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 187 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 188 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 189 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7424 - i32.store - local.get $0 - i32.const 190 - i32.const 7424 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7456 - i32.store - local.get $0 - i32.const 191 - i32.const 7456 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7488 - i32.store - local.get $0 - i32.const 192 - i32.const 7488 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7520 - i32.store - local.get $0 - i32.const 193 - i32.const 7520 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7568 - i32.store - local.get $0 - i32.const 194 - i32.const 7568 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7616 - i32.store - local.get $0 - i32.const 195 - i32.const 7616 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7664 - i32.store - local.get $0 - i32.const 196 - i32.const 7664 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7712 - i32.store - local.get $0 - i32.const 197 - i32.const 7712 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7760 - i32.store - local.get $0 - i32.const 198 - i32.const 7760 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7808 - i32.store - local.get $0 - i32.const 199 - i32.const 7808 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7856 - i32.store - local.get $0 - i32.const 200 - i32.const 7856 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7888 - i32.store - local.get $0 - i32.const 201 - i32.const 7888 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7920 - i32.store - local.get $0 - i32.const 202 - i32.const 7920 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 7952 - i32.store - local.get $0 - i32.const 203 - i32.const 7952 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8000 - i32.store - local.get $0 - i32.const 204 - i32.const 8000 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8048 - i32.store - local.get $0 - i32.const 205 - i32.const 8048 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8096 - i32.store - local.get $0 - i32.const 206 - i32.const 8096 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8144 - i32.store - local.get $0 - i32.const 207 - i32.const 8144 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8192 - i32.store - local.get $0 - i32.const 208 - i32.const 8192 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8240 - i32.store - local.get $0 - i32.const 209 - i32.const 8240 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8288 - i32.store - local.get $0 - i32.const 210 - i32.const 8288 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8320 - i32.store - local.get $0 - i32.const 211 - i32.const 8320 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8352 - i32.store - local.get $0 - i32.const 212 - i32.const 8352 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8384 - i32.store - local.get $0 - i32.const 213 - i32.const 8384 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8432 - i32.store - local.get $0 - i32.const 214 - i32.const 8432 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8480 - i32.store - local.get $0 - i32.const 215 - i32.const 8480 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8528 - i32.store - local.get $0 - i32.const 216 - i32.const 8528 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8576 - i32.store - local.get $0 - i32.const 217 - i32.const 8576 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8624 - i32.store - local.get $0 - i32.const 218 - i32.const 8624 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8672 - i32.store - local.get $0 - i32.const 219 - i32.const 8672 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8720 - i32.store - local.get $0 - i32.const 220 - i32.const 8720 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8768 - i32.store - local.get $0 - i32.const 221 - i32.const 8768 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8816 - i32.store - local.get $0 - i32.const 222 - i32.const 8816 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8864 - i32.store - local.get $0 - i32.const 223 - i32.const 8864 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8912 - i32.store - local.get $0 - i32.const 224 - i32.const 8912 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8960 - i32.store - local.get $0 - i32.const 225 - i32.const 8960 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 8992 - i32.store - local.get $0 - i32.const 226 - i32.const 8992 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 9024 - i32.store - local.get $0 - i32.const 227 - i32.const 9024 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 9056 - i32.store - local.get $0 - i32.const 228 - i32.const 9056 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 9088 - i32.store - local.get $0 - i32.const 229 - i32.const 9088 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - i32.const 9120 - i32.store - local.get $0 - i32.const 230 - i32.const 9120 - i32.const 12 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/INSTRUCTIONS - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MaybePageFault#constructor (result i32) - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 11 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store8 offset=1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/typedarray/Uint8Array#constructor (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $1 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 3 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store - local.get $1 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=8 - local.get $0 - i32.const 1073741820 - i32.gt_u - if - i32.const 9200 - i32.const 9248 - i32.const 19 - i32.const 57 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.store - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory-page/Page#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 12 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $2 - local.get $1 - i32.store offset=4 - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/memory-page/RawPage#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 13 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $2 - local.get $1 - i32.store offset=4 - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i64) - (local $2 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 3 - i32.shl - i32.add - i64.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.const 3 - i32.shl - i32.add - local.get $2 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/OutcomeData#constructor (result i32) - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.const 19 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $start:assembly/instructions/bit~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.popcnt - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.popcnt - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.clz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.clz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.ctz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.ctz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.extend8_s - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.extend16_s - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.const 65535 - i32.and - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.tee $3 - i64.const 8 - i64.shr_u - i64.const 71777214294589695 - i64.and - local.get $3 - i64.const 71777214294589695 - i64.and - i64.const 8 - i64.shl - i64.or - local.tee $3 - i64.const 16 - i64.shr_u - i64.const 281470681808895 - i64.and - local.get $3 - i64.const 281470681808895 - i64.and - i64.const 16 - i64.shl - i64.or - i64.const 32 - i64.rotr - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/staticJump (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/branch~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.ne - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $3 - i64.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.ge_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.ne - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/jump~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/dJump (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/jump~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.add - i32.wrap_i64 - call $assembly/instructions/outcome/dJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/jump~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=4 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - call $assembly/instructions/outcome/staticJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/jump~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=12 - i64.add - i32.wrap_i64 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/dJump - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_u offset=8 - i64.const 32 - i64.shl - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=4 - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Chunks#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 24 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $3 - local.get $0 - i32.store - local.get $3 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - i32.store offset=4 - local.get $3 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $3 - local.get $2 - i32.store offset=8 - local.get $3 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/Chunks#constructor@varargs (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $1 - i32.store - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $2 - i32.store offset=4 - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=20 - local.get $0 - local.get $1 - local.get $2 - call $assembly/memory/Chunks#constructor - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#find" (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.load offset=4 - i32.and - i32.const 2 - i32.shl - i32.add - i32.load - local.set $0 - loop $while-continue|0 - local.get $0 - if - local.get $0 - i32.load offset=8 - local.tee $2 - i32.const 1 - i32.and - if (result i32) - i32.const 0 - else - local.get $1 - local.get $0 - i32.load - i32.eq - end - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - local.get $2 - i32.const -2 - i32.and - local.set $0 - br $while-continue|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $"~lib/map/Map#has" (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $1 - i32.const -1028477379 - i32.mul - i32.const 374761397 - i32.add - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.tee $0 - local.get $0 - i32.const 15 - i32.shr_u - i32.xor - i32.const -2048144777 - i32.mul - local.tee $0 - local.get $0 - i32.const 13 - i32.shr_u - i32.xor - i32.const -1028477379 - i32.mul - local.tee $0 - local.get $0 - i32.const 16 - i32.shr_u - i32.xor - call $"~lib/map/Map#find" - i32.const 0 - i32.ne - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/PageData#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 25 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $3 - local.get $0 - i32.store - local.get $3 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - i32.store offset=4 - local.get $3 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/fault (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/memory/MaybePageFault#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 1 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $"~lib/map/Map#get" (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $1 - i32.const -1028477379 - i32.mul - i32.const 374761397 - i32.add - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.tee $0 - local.get $0 - i32.const 15 - i32.shr_u - i32.xor - i32.const -2048144777 - i32.mul - local.tee $0 - local.get $0 - i32.const 13 - i32.shr_u - i32.xor - i32.const -1028477379 - i32.mul - local.tee $0 - local.get $0 - i32.const 16 - i32.shr_u - i32.xor - call $"~lib/map/Map#find" - local.tee $0 - i32.eqz - if - i32.const 10400 - i32.const 10464 - i32.const 105 - i32.const 17 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory-page/Page#can (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - i32.const 2 - i32.eq - if (result i32) - i32.const 1 - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load - i32.eq - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getPage (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $2 - i32.const 4095 - i32.and - local.set $3 - local.get $2 - i32.const 12 - i32.shr_u - local.tee $4 - i32.const 12 - i32.shl - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $2 - i32.store - block $folding-inner0 - local.get $2 - local.get $4 - call $"~lib/map/Map#has" - i32.eqz - if - local.get $5 - call $assembly/memory/fault - local.set $2 - br $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $4 - call $"~lib/map/Map#get" - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $5 - call $assembly/memory/fault - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - i32.store8 offset=1 - br $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - local.get $0 - local.get $3 - call $assembly/memory/PageData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_PAGE - local.tee $0 - i32.store offset=4 - local.get $2 - local.get $0 - local.get $3 - call $assembly/memory/PageData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#fill@varargs (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $1of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 2147483647 - local.set $1 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.tee $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.le_s - select - local.tee $3 - local.get $1 - local.get $2 - local.get $1 - local.get $2 - i32.lt_s - select - local.tee $1 - i32.lt_s - if - local.get $3 - local.get $4 - i32.add - i32.const 0 - local.get $1 - local.get $3 - i32.sub - memory.fill - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory-page/RawPage#get:data (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 4096 - call $~lib/typedarray/Uint8Array#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - i32.const 1 - global.set $~argumentsLength - local.get $1 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 10640 - i32.const 46 - i32.const 12 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/memory/Memory#getChunks (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - block $folding-inner2 (result i32) - block $folding-inner1 - local.get $3 - i32.const 255 - i32.and - i32.eqz - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $0 - i32.store - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - local.get $2 - call $assembly/memory/Memory#getPage - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load - local.tee $5 - i32.store - local.get $5 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load - local.tee $0 - i32.store - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load offset=4 - local.tee $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.load offset=8 - local.tee $4 - local.get $3 - i32.const 255 - i32.and - i32.add - local.tee $6 - i32.const 4096 - i32.le_u - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $1 - i32.store offset=8 - local.get $1 - call $assembly/memory-page/RawPage#get:data - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $4 - local.get $6 - call $~lib/typedarray/Uint8Array#subarray - local.tee $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 2 - global.set $~argumentsLength - local.get $1 - local.get $0 - call $assembly/memory/Chunks#constructor@varargs - br $folding-inner2 - end - local.get $2 - local.get $3 - i32.const 255 - i32.and - i32.add - i64.extend_i32_u - i64.const 4294967295 - i64.and - i32.wrap_i64 - i32.const 12 - i32.shr_u - local.tee $6 - i32.const 12 - i32.shl - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $7 - i32.store - block $folding-inner0 - local.get $7 - local.get $6 - call $"~lib/map/Map#has" - i32.eqz - if - local.get $2 - call $assembly/memory/fault - local.set $0 - br $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $6 - call $"~lib/map/Map#get" - local.tee $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $2 - call $assembly/memory/fault - local.tee $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store8 offset=1 - br $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $2 - i32.store offset=8 - local.get $2 - call $assembly/memory-page/RawPage#get:data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - i32.const 1 - global.set $~argumentsLength - local.get $2 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $1 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=8 - local.get $0 - call $assembly/memory-page/RawPage#get:data - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - local.get $4 - local.get $3 - i32.const 255 - i32.and - i32.add - i32.const 4096 - i32.sub - call $~lib/typedarray/Uint8Array#subarray - local.tee $0 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - local.get $2 - local.get $1 - local.get $0 - call $assembly/memory/Chunks#constructor - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - end - i32.const 1 - global.set $~argumentsLength - local.get $0 - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - end - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/ChunkBytes#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 22 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $2 - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $2 - local.get $1 - i32.store offset=4 - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.add - local.get $2 - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getBytes (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 1 - local.get $1 - local.get $2 - call $assembly/memory/Memory#getChunks - local.tee $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $0 - i32.store - local.get $0 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $0 - i32.store - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $~lib/staticarray/StaticArray#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $0 - local.get $1 - call $assembly/memory/ChunkBytes#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=8 - local.tee $4 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.const 255 - i32.and - call $~lib/staticarray/StaticArray#constructor - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $6 - loop $for-loop|0 - local.get $3 - local.get $6 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $2 - local.get $3 - local.get $0 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - i32.const 0 - local.set $0 - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $2 - local.get $0 - local.get $6 - i32.add - local.get $4 - local.get $0 - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $0 - i32.const 1 - i32.add - local.set $0 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $0 - local.get $2 - call $assembly/memory/ChunkBytes#constructor - local.set $0 - br $folding-inner1 - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/memory/Result#constructor (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 21 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - call $assembly/memory/MaybePageFault#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.add - i32.load8_u - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getU8 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/instructions/outcome/okOrFault (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 2 - i32.const 1 - local.get $0 - i32.load8_u offset=1 - select - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.load offset=4 - i32.store offset=16 - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getU8 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getI8 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $1 - local.get $0 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i32.extend8_s - i64.extend_i32_s - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getI8 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getU16 (param $0 i32) (param $1 i32) (result i32) - (local $2 i64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.store offset=8 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $0 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getU16 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getI16 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - local.get $2 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i32.or - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $0 - i32.extend16_s - i64.extend_i32_s - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getI16 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getU32 (param $0 i32) (param $1 i32) (result i32) - (local $2 i64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.store offset=8 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i64.extend_i32_u - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $0 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i64.extend_i32_u - i64.or - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getU32 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getI32 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=12 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - local.get $2 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store - local.get $3 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store - local.get $3 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i32.or - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $0 - i64.extend_i32_s - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getI32 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#getU64 (param $0 i32) (param $1 i32) (result i32) - (local $2 i64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.const 8 - call $assembly/memory/Memory#getBytes - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.store offset=8 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $3 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 8 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 16 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 24 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 4 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 32 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 5 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 40 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $3 - i32.const 6 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 48 - i64.shl - i64.or - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i64.load - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store offset=12 - local.get $1 - local.get $2 - local.get $0 - i32.const 7 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 56 - i64.shl - i64.or - i64.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/load~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#getU64 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getU8 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getI8 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getU16 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getI16 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getU32 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getI32 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/load~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - call $assembly/memory/Memory#getU64 - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.xor - i64.const -1 - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $3 - local.get $5 - i64.add - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_u offset=8 - i64.mul - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_u offset=8 - i64.const 4294967296 - i64.or - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $4 - i32.add - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 4294967296 - i64.add - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - i64.sub - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.mul - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.tee $2 - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.div_u - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const -1 - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.extend32_s - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.extend32_s - local.tee $4 - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const -1 - call $~lib/staticarray/StaticArray#__set - else - local.get $3 - i64.const -2147483648 - i64.eq - local.get $4 - i64.const -1 - i64.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $3 - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $3 - local.get $4 - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - local.get $2 - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.rem_u - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.tee $4 - if - local.get $2 - i32.const -2147483648 - i32.eq - local.get $4 - i32.const -1 - i32.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_s - local.get $4 - i64.extend_i32_s - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.sub - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const -1 - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.div_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|17 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.tee $4 - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const -1 - call $~lib/staticarray/StaticArray#__set - else - local.get $3 - i64.const -9223372036854775808 - i64.eq - local.get $4 - i64.const -1 - i64.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $3 - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $3 - local.get $4 - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|18 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.rem_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|19 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.tee $4 - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $3 - call $~lib/staticarray/StaticArray#__set - else - local.get $3 - i64.const -9223372036854775808 - i64.eq - local.get $4 - i64.const -1 - i64.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $3 - local.get $4 - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|20 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - (local $6 i64) - (local $7 i64) - (local $8 i64) - (local $9 i64) - (local $10 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - block $__inlined_func$assembly/instructions/utils/mulUpperSigned$4 (result i64) - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - local.get $4 - i64.const 0 - i64.lt_s - if (result i32) - local.get $4 - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $4 - i32.const 1 - else - i32.const 0 - end - local.set $0 - local.get $3 - i64.const 0 - i64.lt_s - if (result i32) - local.get $3 - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $3 - local.get $0 - i32.eqz - else - local.get $0 - end - if - local.get $3 - i64.const 32 - i64.shr_u - local.tee $8 - local.get $4 - i64.const 4294967295 - i64.and - local.tee $5 - i64.mul - local.set $6 - local.get $4 - i64.const 32 - i64.shr_u - local.tee $7 - local.get $3 - i64.const 4294967295 - i64.and - local.tee $9 - i64.mul - local.set $10 - local.get $3 - local.get $4 - i64.mul - i64.eqz - i64.extend_i32_u - local.get $7 - local.get $8 - i64.mul - local.get $6 - i64.const 32 - i64.shr_u - i64.add - local.get $10 - i64.const 32 - i64.shr_u - i64.add - local.get $6 - i64.const 4294967295 - i64.and - local.get $5 - local.get $9 - i64.mul - i64.const 32 - i64.shr_u - i64.add - local.get $10 - i64.const 4294967295 - i64.and - i64.add - i64.const 32 - i64.shr_u - i64.add - i64.const -1 - i64.xor - i64.add - br $__inlined_func$assembly/instructions/utils/mulUpperSigned$4 - end - local.get $3 - i64.const 32 - i64.shr_u - local.tee $5 - local.get $4 - i64.const 4294967295 - i64.and - local.tee $6 - i64.mul - local.set $7 - local.get $4 - i64.const 32 - i64.shr_u - local.tee $4 - local.get $5 - i64.mul - local.get $7 - i64.const 32 - i64.shr_u - i64.add - local.get $3 - i64.const 4294967295 - i64.and - local.tee $3 - local.get $4 - i64.mul - local.tee $4 - i64.const 32 - i64.shr_u - i64.add - local.get $7 - i64.const 4294967295 - i64.and - local.get $3 - local.get $6 - i64.mul - i64.const 32 - i64.shr_u - i64.add - local.get $4 - i64.const 4294967295 - i64.and - i64.add - i64.const 32 - i64.shr_u - i64.add - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|21 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - (local $6 i64) - (local $7 i64) - (local $8 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.tee $5 - i64.const 32 - i64.shr_u - local.set $6 - local.get $4 - i64.const 32 - i64.shr_u - local.tee $7 - local.get $5 - i64.const 4294967295 - i64.and - local.tee $5 - i64.mul - local.set $8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $6 - local.get $7 - i64.mul - local.get $4 - i64.const 4294967295 - i64.and - local.tee $3 - local.get $6 - i64.mul - local.tee $4 - i64.const 32 - i64.shr_u - i64.add - local.get $8 - i64.const 32 - i64.shr_u - i64.add - local.get $4 - i64.const 4294967295 - i64.and - local.get $3 - local.get $5 - i64.mul - i64.const 32 - i64.shr_u - i64.add - local.get $8 - i64.const 4294967295 - i64.and - i64.add - i64.const 32 - i64.shr_u - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|22 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - (local $6 i64) - (local $7 i64) - (local $8 i64) - (local $9 i64) - (local $10 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - block $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2459 (result i64) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $5 - local.get $3 - i64.const 0 - i64.lt_s - if - local.get $3 - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.tee $6 - i64.const 4294967295 - i64.and - local.tee $7 - local.get $5 - i64.const 32 - i64.shr_u - local.tee $8 - i64.mul - local.set $3 - local.get $6 - i64.const 32 - i64.shr_u - local.tee $4 - local.get $5 - i64.const 4294967295 - i64.and - local.tee $9 - i64.mul - local.set $10 - local.get $5 - local.get $6 - i64.mul - i64.eqz - i64.extend_i32_u - local.get $4 - local.get $8 - i64.mul - local.get $3 - i64.const 32 - i64.shr_u - i64.add - local.get $10 - i64.const 32 - i64.shr_u - i64.add - local.get $3 - i64.const 4294967295 - i64.and - local.get $7 - local.get $9 - i64.mul - i64.const 32 - i64.shr_u - i64.add - local.get $10 - i64.const 4294967295 - i64.and - i64.add - i64.const 32 - i64.shr_u - i64.add - i64.const -1 - i64.xor - i64.add - br $__inlined_func$assembly/instructions/utils/mulUpperSignedUnsigned$2459 - end - local.get $3 - i64.const 4294967295 - i64.and - local.tee $4 - local.get $5 - i64.const 32 - i64.shr_u - local.tee $6 - i64.mul - local.set $7 - local.get $3 - i64.const 32 - i64.shr_u - local.tee $3 - local.get $5 - i64.const 4294967295 - i64.and - local.tee $5 - i64.mul - local.set $8 - local.get $3 - local.get $6 - i64.mul - local.get $7 - i64.const 32 - i64.shr_u - i64.add - local.get $8 - i64.const 32 - i64.shr_u - i64.add - local.get $7 - i64.const 4294967295 - i64.and - local.get $4 - local.get $5 - i64.mul - i64.const 32 - i64.shr_u - i64.add - local.get $8 - i64.const 4294967295 - i64.and - i64.add - i64.const 32 - i64.shr_u - i64.add - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|23 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $3 - local.get $3 - local.get $4 - i64.lt_s - select - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|24 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $3 - local.get $3 - local.get $4 - i64.lt_u - select - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|25 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $3 - local.get $3 - local.get $4 - i64.gt_s - select - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|26 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $5 - i32.wrap_i64 - local.get $5 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $3 - local.get $3 - local.get $4 - i64.gt_u - select - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/misc~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/array/Array#get:length (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/console/console.log (param $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/bindings/dom/console.log - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory-page/Arena#acquire (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length - i32.const 0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load offset=12 - local.tee $0 - i32.const 0 - i32.le_s - if - i32.const 12448 - i32.const 9152 - i32.const 271 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.get $0 - i32.const 1 - i32.sub - local.tee $0 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 12 - i32.shl - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 12496 - i32.store - i32.const 12496 - call $~lib/console/console.log - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 536870912 - i32.lt_u - if (result i32) - i32.const 4096 - call $~lib/typedarray/Uint8Array#constructor - else - i32.const 0 - end - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=8 - i32.const 1 - i32.add - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/memory-page/RawPage#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $"~lib/map/Map#set" (param $0 i32) (param $1 i32) (param $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $1 - i32.const -1028477379 - i32.mul - i32.const 374761397 - i32.add - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.tee $3 - local.get $3 - i32.const 15 - i32.shr_u - i32.xor - i32.const -2048144777 - i32.mul - local.tee $3 - local.get $3 - i32.const 13 - i32.shr_u - i32.xor - i32.const -1028477379 - i32.mul - local.tee $3 - local.get $3 - i32.const 16 - i32.shr_u - i32.xor - local.tee $8 - call $"~lib/map/Map#find" - local.tee $3 - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $3 - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=12 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=12 - i32.const 3 - i32.mul - i32.const 4 - i32.div_s - i32.lt_s - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - i32.const 1 - i32.shl - i32.const 1 - i32.or - end - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.shl - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $10 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.const 3 - i32.shl - i32.const 3 - i32.div_s - local.tee $7 - i32.const 12 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=8 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $11 - local.get $0 - i32.load offset=16 - i32.const 12 - i32.mul - i32.add - local.set $6 - local.get $4 - local.set $3 - loop $while-continue|0 - local.get $6 - local.get $11 - i32.ne - if - local.get $11 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - local.get $3 - local.get $11 - i32.load - local.tee $12 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.load offset=4 - local.tee $5 - i32.store offset=8 - local.get $3 - local.get $5 - i32.store offset=4 - local.get $3 - local.get $10 - local.get $9 - local.get $12 - i32.const -1028477379 - i32.mul - i32.const 374761397 - i32.add - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.tee $5 - i32.const 15 - i32.shr_u - local.get $5 - i32.xor - i32.const -2048144777 - i32.mul - local.tee $5 - i32.const 13 - i32.shr_u - local.get $5 - i32.xor - i32.const -1028477379 - i32.mul - local.tee $5 - i32.const 16 - i32.shr_u - local.get $5 - i32.xor - i32.and - i32.const 2 - i32.shl - i32.add - local.tee $5 - i32.load - i32.store offset=8 - local.get $5 - local.get $3 - i32.store - local.get $3 - i32.const 12 - i32.add - local.set $3 - end - local.get $11 - i32.const 12 - i32.add - local.set $11 - br $while-continue|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $0 - local.get $10 - i32.store - local.get $0 - local.get $10 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $0 - local.get $4 - i32.store offset=8 - local.get $0 - local.get $4 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - local.get $7 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $0 - local.get $0 - i32.load offset=20 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=16 - local.tee $4 - i32.const 1 - i32.add - i32.store offset=16 - local.get $3 - local.get $4 - i32.const 12 - i32.mul - i32.add - local.tee $3 - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $3 - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=20 - i32.const 1 - i32.add - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $3 - local.get $1 - local.get $8 - local.get $0 - i32.load offset=4 - i32.and - i32.const 2 - i32.shl - i32.add - local.tee $0 - i32.load - i32.store offset=8 - local.get $0 - local.get $3 - i32.store - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $start:assembly/instructions/misc~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - call $assembly/memory/Result#constructor - local.tee $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $6 - local.get $2 - i64.load32_u offset=12 - i64.store - block $folding-inner0 - local.get $4 - i32.eqz - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i64.load32_u offset=12 - local.get $4 - i64.extend_i32_u - i64.add - local.tee $3 - i64.const 4294967296 - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=8 - local.tee $2 - i32.store offset=4 - local.get $2 - i32.const 1 - i32.store8 - br $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $3 - i64.store32 offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $3 - i64.const 1 - i64.sub - i64.const 12 - i64.shr_s - i32.wrap_i64 - local.tee $5 - local.get $2 - i32.load - i32.eq - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.load - i32.const 1 - i32.add - local.set $4 - loop $for-loop|0 - local.get $4 - local.get $5 - i32.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - local.tee $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - call $assembly/memory-page/Arena#acquire - local.tee $7 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - i32.const 2 - local.get $7 - call $assembly/memory-page/Page#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $8 - local.get $4 - local.get $7 - call $"~lib/map/Map#set" - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $5 - i32.store - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $4 - i32.store - local.get $4 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.load - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $start:assembly/instructions/mov~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/mov~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $0 - i64.load32_s offset=8 - i64.rotr - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_s offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.rotr - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $0 - i32.load offset=8 - i32.rotr - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=8 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.rotr - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.rotl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.rotl - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.rotr - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - local.get $2 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.rotr - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.lt_u - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.lt_s - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.gt_u - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.gt_s - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $2 - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.gt_u - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/set~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $4 - i64.gt_s - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 31 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.shl - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 31 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.shr_u - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 31 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.extend32_s - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i32.load offset=8 - local.get $2 - i32.shl - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i32.load offset=8 - local.get $2 - i32.shr_u - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i64.extend_i32_u - i64.shr_s - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 63 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $2 - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 63 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $2 - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - i32.const 63 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - local.get $2 - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $0 - i64.load32_s offset=8 - local.get $2 - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i64.extend_i32_u - i64.shr_s - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.shl - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i32.shr_u - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 31 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.extend32_s - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=8 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $4 - local.get $2 - i64.extend_i32_u - i64.shr_s - i64.extend32_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $2 - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $2 - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/shift~anonymous|17 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 63 - i64.and - i32.wrap_i64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.load32_u offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - i32.const 12 - local.get $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - local.get $2 - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/OutcomeData#constructor - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#__set (param $0 i32) (param $1 i32) (param $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=8 - i32.ge_u - if - i32.const 1504 - i32.const 1744 - i32.const 178 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - local.get $2 - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 2 - local.get $1 - i32.const 1 - call $assembly/memory/Memory#getChunks - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - local.get $1 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $1 - i32.store - local.get $1 - i32.const 0 - local.get $2 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=4 - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU16 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 2 - local.get $1 - i32.const 2 - call $assembly/memory/Memory#getChunks - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - local.get $1 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $1 - i32.store - local.get $1 - i32.const 0 - local.get $2 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $1 - i32.store - local.get $1 - i32.const 1 - local.get $2 - i32.const 65535 - i32.and - i32.const 8 - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $1 - i32.store - local.get $1 - i32.const 0 - local.get $2 - i32.const 65535 - i32.and - i32.const 8 - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|1 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=4 - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU32 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 2 - local.get $1 - i32.const 4 - call $assembly/memory/Memory#getChunks - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $0 - i32.store - local.get $0 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - loop $for-loop|0 - local.get $3 - local.get $4 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - local.get $3 - local.get $2 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 8 - i32.shr_u - local.set $2 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - i32.const 0 - local.set $3 - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $3 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - local.get $3 - local.get $2 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 8 - i32.shr_u - local.set $2 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|2 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=4 - call $assembly/memory/Memory#setU32 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU64 (param $0 i32) (param $1 i32) (param $2 i64) (result i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 2 - local.get $1 - i32.const 8 - call $assembly/memory/Memory#getChunks - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $0 - i32.store - local.get $0 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - loop $for-loop|0 - local.get $3 - local.get $4 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - local.get $3 - local.get $2 - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i64.const 8 - i64.shr_u - local.set $2 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - i32.const 0 - local.set $3 - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $3 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $0 - i32.store - local.get $0 - local.get $3 - local.get $2 - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i64.const 8 - i64.shr_u - local.set $2 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|3 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i64.load32_s offset=4 - call $assembly/memory/Memory#setU64 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|4 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|5 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|6 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|7 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|8 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.add - i32.wrap_i64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=8 - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|9 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.add - i32.wrap_i64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=8 - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|10 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.add - i32.wrap_i64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i32.load offset=8 - call $assembly/memory/Memory#setU32 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|11 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=4 - i64.add - i32.wrap_i64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $1 - local.get $0 - i64.load32_s offset=8 - call $assembly/memory/Memory#setU64 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|12 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|13 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|14 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/store~anonymous|15 (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i64.load32_s offset=8 - i64.add - i32.wrap_i64 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $4 - local.get $1 - i32.const 12 - local.get $0 - i64.load32_u offset=4 - local.tee $3 - i32.wrap_i64 - local.get $3 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/instructions/outcome/okOrFault - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - i32.load8_u - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/codec~anonymous|0 (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15344 - i32.store - i32.const 15344 - call $~lib/array/Array#get:length - local.set $2 - loop $for-loop|0 - local.get $1 - local.get $2 - i32.const 255 - i32.and - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - i32.const 15344 - i32.store - i32.const 15344 - local.get $1 - call $~lib/array/Array#__get - local.get $0 - i32.const 255 - i32.and - i32.le_u - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 8 - local.get $1 - i32.sub - return - end - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/Mask#isInstruction (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i64.extend_i32_s - local.get $1 - i64.extend_i32_u - i64.le_u - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - i32.eqz - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $0 - i32.eqz - if - i32.const 15728 - i32.const 9152 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/string/String#concat (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - local.tee $3 - local.get $2 - i32.add - local.tee $4 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15504 - return - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $4 - i32.store offset=4 - local.get $4 - local.get $0 - local.get $2 - memory.copy - local.get $2 - local.get $4 - i32.add - local.get $1 - local.get $3 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/string/String.__concat (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - call $~lib/string/String#concat - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/util/string/joinStringArray (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $1 - i32.const 1 - i32.sub - local.tee $5 - i32.const 0 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15504 - return - end - local.get $5 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - i32.const 15504 - local.get $0 - select - return - end - loop $for-loop|0 - local.get $1 - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $4 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $6 - i32.store offset=4 - local.get $6 - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $3 - local.get $6 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - i32.add - local.set $3 - end - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|0 - end - end - i32.const 0 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $2 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - local.tee $1 - local.get $5 - i32.mul - i32.add - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $6 - i32.store offset=12 - i32.const 0 - local.set $3 - loop $for-loop|1 - local.get $3 - local.get $5 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $3 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $7 - i32.store offset=4 - local.get $7 - if - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $6 - local.get $4 - i32.const 1 - i32.shl - i32.add - local.get $7 - local.get $7 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - local.tee $7 - i32.const 1 - i32.shl - memory.copy - local.get $4 - local.get $7 - i32.add - local.set $4 - end - local.get $1 - if - local.get $6 - local.get $4 - i32.const 1 - i32.shl - i32.add - local.get $2 - local.get $1 - i32.const 1 - i32.shl - memory.copy - local.get $1 - local.get $4 - i32.add - local.set $4 - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $5 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $0 - i32.store offset=4 - local.get $0 - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $6 - local.get $4 - i32.const 1 - i32.shl - i32.add - local.get $0 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - memory.copy - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store - local.get $0 - local.get $1 - i32.const 15504 - call $~lib/util/string/joinStringArray - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/Mask#skipBytesToNextInstruction (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $1 - i32.const 1 - i32.add - local.tee $1 - local.get $2 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $0 - i32.store offset=4 - local.get $0 - i32.eqz - if - i32.const 15728 - i32.const 9152 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/program/decodeArguments (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 1264 - i32.store - i32.const 1264 - local.get $0 - call $~lib/array/Array#__get - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 1264 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 1264 - local.get $0 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#constructor - local.tee $4 - i32.store offset=4 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $3 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $4 - local.get $3 - local.get $1 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - i32.const 2 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 2272 - i32.store offset=8 - local.get $4 - local.get $2 - i32.const 2272 - local.get $0 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $1) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 2 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 2272 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 2272 - local.get $0 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $1) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-internal/getAssembly (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $4 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15424 - return - end - i32.const 15504 - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=8 - loop $for-loop|0 - local.get $3 - local.get $4 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - local.get $2 - local.get $3 - call $assembly/program/Mask#isInstruction - i32.eqz - if - i32.const 15536 - i32.const 15648 - i32.const 48 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $2 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - local.set $2 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $5 - i32.store - local.get $2 - local.get $5 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $5 - i32.store - local.get $5 - local.get $2 - call $~lib/array/Array#__get - end - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15856 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 15856 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - call $~lib/number/I32#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 17664 - i32.store offset=16 - local.get $7 - i32.const 17664 - call $~lib/string/String#concat - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $1 - local.get $7 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $6 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.const 255 - i32.and - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $2 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 17760 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - i32.const 17764 - local.get $2 - i32.store - i32.const 17760 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 17760 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=16 - i32.const 17760 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $1 - local.get $2 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - local.get $2 - local.get $3 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $8 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - local.get $8 - local.get $3 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $6 - call $assembly/program/decodeArguments - local.tee $2 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - i32.const 38 - i32.const 0 - call $~lib/rt/__newArray - local.tee $8 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 0 - local.get $2 - i32.load - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 1 - local.get $2 - i32.load offset=4 - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 2 - local.get $2 - i32.load offset=8 - call $~lib/array/Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $8 - i32.const 3 - local.get $2 - i32.load offset=12 - call $~lib/array/Array#__set - local.get $8 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 1136 - i32.store - i32.const 1136 - local.get $5 - i32.load offset=4 - call $~lib/array/Array#__get - local.set $5 - i32.const 0 - local.set $2 - loop $for-loop|1 - local.get $2 - local.get $5 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $8 - local.get $2 - call $~lib/array/Array#__get - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $9 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - i32.const 17856 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - i32.const 17860 - local.get $9 - i32.store - i32.const 17856 - local.get $9 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 17856 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=16 - i32.const 17856 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $1 - local.get $9 - call $~lib/string/String.__concat - local.tee $1 - i32.store offset=8 - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end - end - local.get $3 - local.get $6 - i32.add - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/program-build/skipBytes (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $folding-inner3 (result i32) - block $folding-inner2 - block $folding-inner1 - block $folding-inner0 - block $case13|0 - block $case12|0 - block $case11|0 - block $case8|0 - block $case7|0 - block $case6|0 - block $case5|0 - block $case4|0 - block $case2|0 - block $case0|0 - local.get $0 - br_table $case0|0 $folding-inner0 $case2|0 $folding-inner0 $case4|0 $case5|0 $case6|0 $case7|0 $case8|0 $folding-inner2 $folding-inner2 $case11|0 $case12|0 $case13|0 - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u - i32.const 1 - i32.add - local.tee $0 - i32.const 255 - i32.and - i32.const 1 - i32.add - block $__inlined_func$assembly/program-build/immBytes$1606 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $1 - local.get $0 - i32.const 1 - i32.add - i32.const 255 - i32.and - local.tee $0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$1606 - drop - local.get $1 - local.get $0 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - i32.add - br $folding-inner3 - end - block $__inlined_func$assembly/program-build/immBytes$1608 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $0 - i32.const 0 - i32.le_s - br_if $__inlined_func$assembly/program-build/immBytes$1608 - drop - local.get $0 - i32.const 1 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - i32.const 1 - i32.add - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 9 - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=8 - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=12 - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 1 - return - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u - i32.const 1 - i32.add - local.tee $0 - i32.const 255 - i32.and - i32.const 2 - i32.add - block $__inlined_func$assembly/program-build/immBytes$1614 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $1 - local.get $0 - i32.const 255 - i32.and - i32.const 2 - i32.add - local.tee $0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$1614 - drop - local.get $1 - local.get $0 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - i32.add - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 2 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 17888 - i32.store - local.get $0 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - i32.const 17888 - local.get $0 - call $~lib/string/String#concat - i32.const 17968 - i32.const 73 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - block $__inlined_func$assembly/program-build/immBytes$1604 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $0 - i32.const 0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$1604 - drop - local.get $0 - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u offset=1 - i32.const 1 - i32.add - local.tee $0 - i32.const 255 - i32.and - i32.const 1 - i32.add - block $__inlined_func$assembly/program-build/immBytes$1610 (result i32) - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - i32.const 0 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $1 - local.get $0 - i32.const 255 - i32.and - i32.const 1 - i32.add - local.tee $0 - i32.lt_s - br_if $__inlined_func$assembly/program-build/immBytes$1610 - drop - local.get $1 - local.get $0 - i32.sub - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - end - i32.add - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - f64.const 4 - f64.min - i32.trunc_sat_f64_s - i32.const 1 - i32.add - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#push (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $0 - i32.load offset=12 - local.tee $2 - i32.const 1 - i32.add - local.tee $3 - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.load offset=4 - i32.add - local.get $1 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program-build/buildMask (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $3 - i32.const 1073741820 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.const 39 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $2 - call $~lib/typedarray/Uint8Array#__get - local.set $1 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length - local.get $1 - i32.gt_s - if (result i32) - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $4 - i32.store - local.get $4 - local.get $1 - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION - end - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $2 - i32.const 1 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 1264 - i32.store - i32.const 1264 - local.get $1 - i32.load offset=4 - call $~lib/array/Array#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $4 - local.get $2 - i32.const 1 - i32.add - local.tee $4 - i32.add - i32.ge_s - if (result i32) - local.get $1 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - i32.const 1 - global.set $~argumentsLength - local.get $0 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/program-build/skipBytes - local.get $2 - i32.add - else - local.get $2 - end - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 18048 - call $~lib/rt/__newArray - local.tee $4 - i32.store offset=12 - i32.const 0 - local.set $0 - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $0 - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - i32.lt_s - if - i32.const 0 - local.set $2 - local.get $0 - local.set $1 - loop $for-loop|3 - local.get $1 - local.get $0 - i32.const 8 - i32.add - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $2 - i32.const 255 - i32.and - i32.const 1 - i32.shr_u - local.tee $2 - i32.const 128 - i32.or - local.get $2 - local.get $1 - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - i32.lt_s - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $1 - call $~lib/staticarray/StaticArray#__get - else - i32.const 0 - end - select - local.set $2 - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|3 - end - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $2 - call $~lib/array/Array#push - local.get $0 - i32.const 8 - i32.add - local.set $0 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/codec/encodeVarU32 (param $0 i64) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i64) - (local $5 i32) - (local $6 i64) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner2 - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner2 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - local.get $0 - i64.eqz - if - i32.const 1 - call $~lib/typedarray/Uint8Array#constructor - local.set $3 - br $folding-inner1 - end - local.get $0 - i64.const 72057594037927936 - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - i32.const 9 - call $~lib/typedarray/Uint8Array#constructor - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.const 255 - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $3 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/dataview/DataView#constructor@varargs$9 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 40 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store - local.get $1 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 20 - i32.sub - i32.load offset=16 - local.get $5 - i32.lt_u - local.get $5 - i32.const 1073741820 - i32.gt_u - i32.or - if - i32.const 9200 - i32.const 18080 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $1 - local.get $3 - i32.store - local.get $1 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - br $__inlined_func$~lib/dataview/DataView#constructor@varargs$9 - end - br $folding-inner2 - end - local.tee $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner2 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load offset=8 - i32.const 9 - i32.lt_s - if - i32.const 1504 - i32.const 18080 - i32.const 174 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load offset=4 - local.get $0 - i64.store offset=1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i64.const 562949953421312 - local.set $4 - i32.const 7 - local.set $1 - loop $for-loop|0 - local.get $1 - i32.const 0 - i32.ge_s - if - local.get $0 - local.get $4 - i64.ge_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $3 - i32.store offset=16 - i32.const 256 - i32.const 1 - i32.const 8 - local.get $1 - i32.sub - local.tee $2 - i32.shl - i32.const 0 - local.get $2 - i32.const 32 - i32.lt_u - select - i32.sub - i64.extend_i32_s - local.get $0 - i32.const 1 - local.get $1 - i32.const 3 - i32.shl - local.tee $2 - i32.shl - i32.const 0 - local.get $2 - i32.const 32 - i32.lt_u - select - i64.extend_i32_s - local.tee $4 - i64.div_u - i64.add - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - local.get $6 - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $0 - local.get $4 - i64.rem_u - local.set $0 - i32.const 1 - local.set $2 - loop $for-loop|1 - local.get $2 - local.get $1 - i32.const 1 - i32.add - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $2 - local.get $0 - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $0 - i64.const 8 - i64.shr_u - local.set $0 - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end - end - br $folding-inner1 - end - local.get $4 - i64.const 7 - i64.shr_u - local.set $4 - local.get $1 - i32.const 1 - i32.sub - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 18144 - i32.store offset=4 - local.get $0 - i32.const 10 - call $~lib/util/number/utoa64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - i32.const 18144 - local.get $1 - call $~lib/string/String#concat - i32.const 18224 - i32.const 160 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/program/liftBytes (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - call $~lib/array/Array#get:length - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.lt_s - if - i32.const 1504 - i32.const 1744 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=4 - local.get $2 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/codec/Decoder#constructor (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 42 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/codec/Decoder#ensureBytes (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - call $~lib/typedarray/Uint8Array#get:length - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - i32.sub - call $~lib/number/I32#toString - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 18420 - local.get $1 - i32.store - i32.const 18416 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 18428 - local.get $0 - i32.store - i32.const 18416 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 18416 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=4 - i32.const 18416 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 18224 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/ValOffset#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 43 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/codec/Decoder#varU32 (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=4 - local.set $4 - i32.const 1 - global.set $~argumentsLength - local.get $1 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - i32.const 1 - global.set $~argumentsLength - i32.const 15392 - i32.load - call_indirect (type $2) - i32.const 255 - i32.and - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $1 - block $__inlined_func$assembly/codec/decodeVarU32$1 (result i32) - local.get $5 - i32.eqz - if - local.get $1 - i32.const 1 - call $assembly/codec/ValOffset#constructor - br $__inlined_func$assembly/codec/decodeVarU32$1 - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $5 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $5 - call $~lib/number/I32#toString - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - call $~lib/number/I32#toString - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 18624 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - i32.const 18628 - local.get $0 - i32.store - i32.const 18624 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 18624 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - i32.const 18636 - local.get $1 - i32.store - i32.const 18624 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 18624 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=12 - i32.const 18624 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 18224 - i32.const 108 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.const 1 - i32.const 8 - local.get $5 - i32.sub - local.tee $1 - i32.shl - i32.const 0 - local.get $1 - i32.const 32 - i32.lt_u - select - i32.add - i32.const 256 - i32.sub - local.get $5 - i32.const 3 - i32.shl - i32.shl - local.set $6 - local.get $5 - i32.const 1 - i32.sub - local.set $1 - loop $for-loop|0 - local.get $1 - i32.const 0 - i32.ge_s - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $1 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - local.get $2 - i32.const 8 - i32.shl - i32.add - local.set $2 - local.get $1 - i32.const 1 - i32.sub - local.set $1 - br $for-loop|0 - end - end - local.get $2 - local.get $6 - i32.add - local.get $5 - i32.const 1 - i32.add - call $assembly/codec/ValOffset#constructor - end - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $2 - local.get $1 - i32.load offset=4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/codec/Decoder#bytes (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $3 - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $1 - local.get $0 - i32.load offset=4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/program/extractCodeAndMetadata (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/codec/Decoder#constructor - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/codec/Decoder#varU32 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - call $assembly/codec/Decoder#bytes - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $4 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.load offset=4 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $0 - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - local.get $4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 41 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $0 - local.get $3 - i32.store - local.get $0 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/codec/Decoder#u24 (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 3 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - local.get $0 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=4 - i32.const 3 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/Decoder#u32 (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 4 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - local.get $0 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=4 - i32.const 3 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=4 - i32.const 4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/Decoder#isExhausted (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.le_s - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/Decoder#u8 (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $1 - local.get $0 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=4 - i32.const 1 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__set (param $0 i32) (param $1 i32) (param $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.const 2 - i32.shl - i32.add - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $0 i32) (param $1 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.ge_u - if - i32.const 1504 - i32.const 9312 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 2 - i32.shl - i32.add - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/BasicBlocks#constructor (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 34 - call $~lib/rt/itcms/__new - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store - local.get $4 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $5 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $5 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.const 2 - i32.shl - i32.const 35 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $5 - i32.const 0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.const 2 - call $~lib/staticarray/StaticArray#__set - end - loop $for-loop|0 - local.get $3 - local.get $5 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $3 - call $assembly/program/Mask#isInstruction - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $3 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $6 - i32.store offset=4 - local.get $6 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $6 - local.get $0 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#__get - end - i32.load8_u offset=16 - if - local.get $5 - local.get $3 - i32.const 1 - i32.add - local.get $7 - i32.add - local.tee $6 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $6 - i32.const 2 - call $~lib/staticarray/StaticArray#__set - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - local.get $3 - local.get $2 - local.get $3 - call $~lib/staticarray/StaticArray#__get - i32.const 4 - i32.or - call $~lib/staticarray/StaticArray#__set - end - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $4 - local.get $2 - i32.store - local.get $4 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/program/deblob (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i64) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i64) - (local $10 i64) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $14 i32) - (local $15 i32) - (local $16 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/codec/Decoder#constructor - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/codec/Decoder#varU32 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/codec/Decoder#u8 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/codec/Decoder#varU32 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - local.get $5 - i32.mul - call $assembly/codec/Decoder#bytes - local.tee $14 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $11 - call $assembly/codec/Decoder#bytes - local.tee $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $11 - i32.const 7 - i32.add - i32.const 3 - i32.shr_u - call $assembly/codec/Decoder#bytes - local.tee $12 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - global.get $~lib/memory/__stack_pointer - block $__inlined_func$assembly/program/Mask#constructor$17 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 31 - call $~lib/rt/itcms/__new - local.tee $13 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=4 - local.get $13 - i32.const 0 - i32.store - local.get $13 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $11 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.const 2 - i32.shl - i32.const 32 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $13 - local.get $0 - i32.store - local.get $13 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.sub - local.set $1 - loop $for-loop|0 - local.get $1 - i32.const 0 - i32.ge_s - if - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=4 - local.get $12 - local.get $1 - call $~lib/typedarray/Uint8Array#__get - local.set $0 - local.get $1 - i32.const 3 - i32.shl - local.set $15 - i32.const 7 - local.set $2 - loop $for-loop|2 - local.get $2 - i32.const 0 - i32.ge_s - if - local.get $0 - i32.const 128 - i32.and - local.set $16 - local.get $0 - i32.const 1 - i32.shl - local.set $0 - local.get $2 - local.get $15 - i32.add - local.tee $7 - local.get $11 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.load - local.tee $8 - i32.store offset=4 - local.get $8 - local.get $7 - i32.const 25 - i32.const 0 - local.get $6 - i32.const 1 - i32.add - local.get $16 - select - local.tee $6 - local.get $6 - i32.const 25 - i32.ge_u - select - call $~lib/staticarray/StaticArray#__set - end - local.get $2 - i32.const 1 - i32.sub - local.set $2 - br $for-loop|2 - end - end - local.get $1 - i32.const 1 - i32.sub - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - br $__inlined_func$assembly/program/Mask#constructor$17 - end - br $folding-inner1 - end - local.tee $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 33 - call $~lib/rt/itcms/__new - local.tee $7 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - i32.const 0 - i32.store - local.get $7 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.const 255 - i32.and - local.tee $1 - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.div_s - else - i32.const 0 - end - call $~lib/staticarray/StaticArray#constructor - local.tee $8 - i32.store offset=8 - i32.const 0 - local.set $1 - loop $for-loop|01 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - local.get $14 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.gt_s - if - i64.const 0 - local.set $4 - local.get $5 - i32.const 1 - i32.sub - i32.const 255 - i32.and - local.set $2 - loop $for-loop|1 - local.get $2 - i32.const 0 - i32.ge_s - if - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=4 - i64.const -1 - local.get $4 - i64.const 8 - i64.shl - local.tee $9 - local.get $14 - local.get $1 - local.get $2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i64.extend_i32_u - i64.add - local.tee $10 - local.get $4 - local.get $10 - i64.gt_u - local.get $4 - local.get $9 - i64.gt_u - i32.or - select - local.set $4 - local.get $2 - i32.const 1 - i32.sub - local.set $2 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $1 - local.get $5 - i32.const 255 - i32.and - local.tee $2 - i32.div_s - local.get $4 - call $~lib/staticarray/StaticArray#__set - local.get $1 - local.get $2 - i32.add - local.set $1 - br $for-loop|01 - end - end - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $7 - local.get $8 - i32.store - local.get $7 - local.get $8 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $0 - call $assembly/program/BasicBlocks#constructor - local.tee $1 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 30 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $2 - local.get $3 - i32.store - local.get $2 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $2 - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $2 - local.get $7 - i32.store offset=8 - local.get $2 - local.get $7 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $2 - local.get $1 - i32.store offset=12 - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory-page/Arena#constructor (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 16 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store - local.get $0 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 524288 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 17 - i32.const 19056 - call $~lib/rt/__newArray - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $0 - local.get $2 - i32.store - local.get $0 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 128 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $4 - i32.store offset=12 - loop $for-loop|0 - local.get $1 - i32.const 128 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $1 - i32.const 12 - i32.shl - local.tee $3 - local.get $4 - i32.const 20 - i32.sub - i32.load offset=16 - local.tee $5 - i32.gt_u - if - i32.const 1504 - i32.const 1744 - i32.const 1860 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.const 4096 - i32.add - local.get $5 - i32.gt_s - if - i32.const 9200 - i32.const 1744 - i32.const 1874 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $5 - i32.store offset=8 - local.get $5 - local.get $4 - i32.store - local.get $5 - local.get $4 - i32.const 0 - call $~lib/rt/itcms/__link - local.get $5 - i32.const 4096 - i32.store offset=8 - local.get $5 - local.get $3 - local.get $4 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $1 - local.get $5 - call $assembly/memory-page/RawPage#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $2 - i32.load offset=12 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.load offset=4 - local.tee $6 - i32.const 4 - i32.add - local.get $6 - local.get $3 - i32.const 1 - i32.sub - i32.const 2 - i32.shl - memory.copy - local.get $6 - local.get $5 - i32.store - local.get $2 - local.get $5 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory/MemoryBuilder#constructor (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 45 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.const 18 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 16 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.store - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 48 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.store offset=8 - local.get $1 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - call $assembly/memory-page/Arena#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/memory/MemoryBuilder#getOrCreatePageForAddress (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $2 - i32.const 12 - i32.shr_u - local.tee $2 - i32.const 16 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - i32.const 19088 - i32.store - local.get $2 - i32.const 10 - call $~lib/util/number/utoa32 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 19088 - local.get $0 - call $~lib/string/String#concat - i32.const 19184 - i32.const 93 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - local.get $2 - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - call $assembly/memory-page/Arena#acquire - local.tee $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $1 - local.get $3 - call $assembly/memory-page/Page#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $4 - local.get $2 - local.get $1 - call $"~lib/map/Map#set" - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - local.get $0 - local.get $2 - call $"~lib/map/Map#get" - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $0 i32) (param $1 i32) (param $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.set $3 - local.get $2 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - local.get $3 - i32.add - i32.lt_s - end - if - i32.const 1504 - i32.const 1744 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $2 - local.get $0 - i32.load offset=4 - i32.add - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - i32.load offset=4 - local.get $3 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MemoryBuilder#setData (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - loop $while-continue|0 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - local.get $2 - call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress - local.tee $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - i32.const 4096 - local.get $2 - i32.const 4095 - i32.and - local.tee $5 - i32.sub - local.tee $4 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - local.set $4 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $6 - i32.store offset=16 - local.get $6 - call $assembly/memory-page/RawPage#get:data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $3 - i32.const 0 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $6 - local.get $7 - local.get $5 - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $2 - local.get $4 - i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $4 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $3 - i32.store - br $while-continue|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MemoryBuilder#setEmpty (param $0 i32) (param $1 i32) (param $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $1 - local.get $2 - i32.add - local.set $2 - loop $for-loop|0 - local.get $1 - local.get $2 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 2 - local.get $1 - call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress - drop - local.get $1 - i32.const 4096 - i32.add - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MemoryBuilder#build (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 15 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $0 - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $0 - local.get $3 - i32.store offset=8 - local.get $0 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store - local.get $1 - i32.const 12 - i32.shr_u - local.tee $1 - i32.const 16 - i32.lt_u - if - i32.const 19248 - i32.const 19184 - i32.const 119 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $0 - local.get $1 - local.get $1 - i32.const 1 - i32.sub - local.get $3 - local.get $1 - call $"~lib/map/Map#has" - select - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/spi/StandardProgram#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 44 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $3 - local.get $0 - i32.store offset=16 - local.get $3 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - i32.store offset=20 - local.get $3 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $3 - local.get $2 - i32.store offset=24 - local.get $3 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $3 - local.get $0 - i32.store - local.get $3 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/spi/decodeSpi (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.tee $2 - i32.const 16777216 - i32.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 16777216 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 18816 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - i32.const 18820 - local.get $0 - i32.store - i32.const 18816 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 18816 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - i32.const 18828 - local.get $1 - i32.store - i32.const 18816 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 18816 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=12 - i32.const 18816 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 18864 - i32.const 18 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/codec/Decoder#constructor - local.tee $4 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#u24 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#u24 - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 2 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $3 - local.get $4 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#__get - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load - local.tee $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $5 - local.get $4 - i32.load offset=4 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $4 - i32.load offset=4 - i32.const 2 - i32.add - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#u24 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - local.get $8 - call $assembly/codec/Decoder#bytes - local.tee $3 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - local.get $0 - call $assembly/codec/Decoder#bytes - local.tee $9 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#u32 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - local.get $5 - call $assembly/codec/Decoder#bytes - local.tee $5 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 18928 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load - local.tee $0 - i32.store offset=8 - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - i32.load offset=4 - i32.sub - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 18928 - local.get $0 - call $~lib/string/String#concat - i32.const 18224 - i32.const 31 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - call $assembly/program/deblob - local.tee $4 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/MemoryBuilder#constructor - local.tee $5 - i32.store offset=36 - i32.const 65535 - i32.and - i32.const 12 - i32.shl - local.tee $6 - local.get $8 - i32.const 65535 - i32.add - i32.const -65536 - i32.and - i32.const 131072 - i32.add - local.tee $10 - local.get $0 - i32.const 4095 - i32.add - i32.const -4096 - i32.and - i32.add - local.tee $11 - i32.add - local.set $12 - i32.const -16908288 - local.get $7 - i32.const 4095 - i32.add - i32.const -4096 - i32.and - local.tee $7 - i32.sub - local.set $13 - local.get $8 - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $5 - i32.const 1 - i32.const 65536 - local.get $3 - call $assembly/memory/MemoryBuilder#setData - end - local.get $2 - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $5 - i32.const 1 - i32.const -16842752 - local.get $1 - call $assembly/memory/MemoryBuilder#setData - end - local.get $0 - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $5 - i32.const 2 - local.get $10 - local.get $9 - call $assembly/memory/MemoryBuilder#setData - end - local.get $6 - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $11 - local.get $6 - call $assembly/memory/MemoryBuilder#setEmpty - end - local.get $7 - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $13 - local.get $7 - call $assembly/memory/MemoryBuilder#setEmpty - end - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - local.get $12 - call $assembly/memory/MemoryBuilder#build - local.tee $0 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - i32.const 13 - call $~lib/staticarray/StaticArray#constructor - local.tee $1 - i32.store offset=44 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - i64.const 4294901760 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 1 - i64.const 4278059008 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 7 - i64.const 4278124544 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 8 - local.get $2 - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=48 - local.get $4 - local.get $0 - local.get $1 - call $assembly/spi/StandardProgram#constructor - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/interpreter/Interpreter#constructor (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 33 - i32.const 29 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store - local.get $3 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=8 - local.get $3 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=12 - local.get $3 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store8 offset=32 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $3 - local.get $0 - i32.store - local.get $3 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - i32.store offset=4 - local.get $3 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $3 - local.get $2 - i32.store offset=8 - local.get $3 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 46 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $3 - local.get $0 - i32.store offset=12 - local.get $3 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const -1 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const -1 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - i32.store8 offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/array/Array#__set (param $0 i32) (param $1 i32) (param $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - local.get $0 - i32.load offset=12 - i32.ge_u - if - local.get $1 - i32.const 0 - i32.lt_s - if - i32.const 1504 - i32.const 9152 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $0 - local.get $1 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - i32.store offset=12 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $1 - i32.const 2 - i32.shl - i32.add - local.get $2 - i32.store - local.get $0 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#set:length (param $0 i32) (param $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - local.get $1 - i32.const 2 - i32.const 0 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#push (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $0 - i32.load offset=12 - local.tee $2 - i32.const 1 - i32.add - local.tee $3 - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - local.get $2 - i32.const 2 - i32.shl - i32.add - local.get $1 - i32.store - local.get $0 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#free (param $0 i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $6 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load offset=8 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load offset=16 - local.set $6 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 47 - call $~lib/rt/itcms/__new - local.tee $8 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - i32.store - local.get $8 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - i32.store offset=12 - local.get $6 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9152 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - local.get $6 - local.get $6 - i32.const 8 - i32.le_u - select - i32.const 2 - i32.shl - local.tee $9 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $7 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $8 - local.get $7 - i32.store - local.get $8 - local.get $7 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $9 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - loop $for-loop|0 - local.get $3 - local.get $6 - i32.lt_s - if - local.get $5 - local.get $3 - i32.const 12 - i32.mul - i32.add - local.tee $7 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - local.get $8 - local.get $1 - local.get $7 - call $~lib/array/Array#__set - local.get $1 - i32.const 1 - i32.add - local.set $1 - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $1 - call $~lib/array/Array#set:length - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - loop $for-loop|00 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/array/Array#get:length - local.get $2 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - local.get $2 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=4 - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $1 - local.get $3 - call $~lib/array/Array#push - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|00 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 16 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.store - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 48 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 4 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-debugger/fillRegisters (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -8 - i32.and - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length - local.get $3 - i32.ne - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - call $~lib/array/Array#get:length - call $~lib/number/I32#toString - local.tee $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - call $~lib/number/I32#toString - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 19584 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - i32.const 19588 - local.get $0 - i32.store - i32.const 19584 - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19584 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - i32.const 19596 - local.get $1 - i32.store - i32.const 19584 - local.get $1 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 19584 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=12 - i32.const 19584 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 19360 - i32.const 221 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $2 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.lt_s - if - i64.const 0 - local.set $4 - i32.const 0 - local.set $3 - loop $for-loop|1 - local.get $3 - i32.const 8 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $4 - local.get $1 - local.get $2 - i32.const 3 - i32.shl - local.get $3 - i32.add - call $~lib/array/Array#__get - i64.extend_i32_u - local.get $3 - i32.const 3 - i32.shl - i32.const 255 - i32.and - i64.extend_i32_u - i64.shl - i64.or - local.set $4 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $2 - local.get $4 - call $~lib/staticarray/StaticArray#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-internal/InitialChunk#constructor (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 50 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - call $~lib/object/Object#constructor - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 19696 - call $~lib/rt/__newArray - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $0 - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/api-internal/buildMemory (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - i32.const 65536 - local.set $3 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $4 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - i32.load offset=8 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - i32.load - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - i32.load offset=4 - call $~lib/typedarray/Uint8Array#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $0 - local.get $8 - local.get $7 - local.get $9 - call $assembly/memory/MemoryBuilder#setData - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load offset=8 - i32.const 2 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $3 - local.get $6 - i32.load - i32.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load - local.set $3 - end - end - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|0 - end - end - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - local.get $5 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.tee $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $6 - i32.store offset=20 - i32.const 0 - local.set $4 - loop $for-loop|2 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/typedarray/Uint8Array#get:length - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - local.get $6 - local.get $4 - local.get $7 - local.get $4 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|2 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i32.load - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $0 - i32.const 0 - local.get $1 - local.get $6 - call $assembly/memory/MemoryBuilder#setData - local.get $5 - i32.const 1 - i32.add - local.set $5 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - call $assembly/memory/MemoryBuilder#build - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/resetGenericWithMemory (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) (param $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $5 - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - call $assembly/program/liftBytes - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $assembly/program/extractCodeAndMetadata - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/program/liftBytes - end - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/program/deblob - local.tee $7 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 13 - call $~lib/staticarray/StaticArray#constructor - local.tee $5 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $5 - local.get $1 - call $assembly/api-debugger/fillRegisters - global.get $~lib/memory/__stack_pointer - call $assembly/memory/MemoryBuilder#constructor - local.tee $8 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=28 - block $__inlined_func$assembly/api-debugger/readPages$23 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 19632 - call $~lib/rt/__newArray - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - call $assembly/codec/Decoder#constructor - local.tee $2 - i32.store offset=8 - loop $while-continue|0 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner00 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 48 - call $~lib/rt/itcms/__new - local.tee $9 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - call $~lib/object/Object#constructor - local.tee $9 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $9 - local.get $2 - call $assembly/codec/Decoder#u32 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $9 - local.get $2 - call $assembly/codec/Decoder#u32 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $9 - i32.const 2 - i32.const 1 - local.get $2 - call $assembly/codec/Decoder#u8 - select - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $1 - local.get $9 - call $~lib/array/Array#push - br $while-continue|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - br $__inlined_func$assembly/api-debugger/readPages$23 - end - br $folding-inner1 - end - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 51 - i32.const 19664 - call $~lib/rt/__newArray - local.tee $10 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - call $assembly/codec/Decoder#constructor - local.tee $1 - i32.store offset=8 - loop $while-continue|01 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - global.get $~lib/memory/__stack_pointer - call $assembly/api-internal/InitialChunk#constructor - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - local.get $2 - local.get $1 - call $assembly/codec/Decoder#u32 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $assembly/codec/Decoder#u32 - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $11 - call $assembly/codec/Decoder#bytes - local.tee $6 - i32.store offset=20 - i32.const 0 - local.set $3 - loop $for-loop|1 - local.get $3 - local.get $11 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - local.tee $12 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=16 - local.get $12 - local.get $6 - local.get $3 - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#push - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $10 - local.get $2 - call $~lib/array/Array#push - br $while-continue|01 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $8 - local.get $9 - local.get $10 - call $assembly/api-internal/buildMemory - local.tee $0 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $7 - local.get $5 - local.get $0 - call $assembly/interpreter/Interpreter#constructor - local.tee $0 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - local.get $4 - call $assembly/gas/GasCounter#set@override - local.get $0 - global.set $assembly/api-debugger/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/program/BasicBlocks#isStart (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store - local.get $1 - local.get $2 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 2 - i32.shr_u - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $0 - i32.store - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - i32.const 2 - i32.and - i32.const 0 - i32.ne - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $assembly/interpreter/branch (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 53 - call $~lib/rt/itcms/__new - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - call $~lib/object/Object#constructor - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $1 - local.get $2 - i32.add - local.tee $0 - call $assembly/program/BasicBlocks#isStart - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 1 - i32.store8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $0 - i32.store offset=4 - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/interpreter/Interpreter#nextStep (param $0 i32) (result i32) - (local $1 i32) - (local $2 i64) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner6 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner6 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=20 - i32.const 3 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const -1 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=28 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const -1 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const -1 - i32.store offset=24 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - block $folding-inner5 - local.get $0 - i32.load offset=20 - i32.const -1 - i32.ne - br_if $folding-inner5 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - block $folding-inner4 - local.get $0 - i32.load offset=28 - i32.const -1 - i32.ne - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=28 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const -1 - i32.store offset=28 - br $folding-inner4 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=16 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=4 - local.tee $3 - i32.store - local.get $3 - local.get $1 - call $assembly/program/Mask#isInstruction - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - global.get $assembly/instructions/MISSING_INSTRUCTION - i64.load offset=8 - call $assembly/gas/GasCounter#sub@override - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 4 - i32.store offset=20 - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store offset=20 - end - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load - local.tee $3 - i32.store - local.get $3 - local.get $1 - call $~lib/typedarray/Uint8Array#__get - local.set $3 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length - local.get $3 - i32.gt_s - if (result i32) - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $4 - i32.store - local.get $4 - local.get $3 - call $~lib/array/Array#__get - else - global.get $assembly/instructions/MISSING_INSTRUCTION - end - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $5 - i32.store - block $folding-inner3 - block $folding-inner1 - block $folding-inner0 - local.get $5 - local.get $4 - i64.load offset=8 - call $assembly/gas/GasCounter#sub@override - br_if $folding-inner0 - local.get $4 - global.get $assembly/instructions/MISSING_INSTRUCTION - i32.eq - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $5 - i32.store - local.get $5 - local.get $1 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $8 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load - local.tee $8 - i32.store offset=4 - i32.const 1 - global.set $~argumentsLength - local.get $8 - local.get $1 - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $5 - call $assembly/program/decodeArguments - local.tee $6 - i32.store offset=16 - local.get $4 - global.get $assembly/instructions/SBRK - i32.eq - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load8_u offset=32 - else - i32.const 0 - end - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $4 - i32.const 12 - local.get $6 - i64.load32_u - local.tee $2 - i32.wrap_i64 - local.get $2 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - i64.const 4095 - i64.add - i64.const 12 - i64.shr_u - i64.const 4 - i64.shl - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $4 - i32.store - local.get $4 - local.get $2 - call $assembly/gas/GasCounter#sub@override - br_if $folding-inner0 - end - global.get $~lib/memory/__stack_pointer - i32.const 15264 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 15264 - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - local.tee $3 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $7 - i32.store offset=8 - i32.const 3 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $6 - local.get $4 - local.get $7 - local.get $3 - i32.load - call_indirect (type $0) - local.tee $3 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - block $break|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $3 - i32.load - br_table $case3|0 $case1|0 $case0|0 $case2|0 $break|0 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - block $__inlined_func$assembly/interpreter/dJump$24 - block $folding-inner11 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner6 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner6 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 52 - call $~lib/rt/itcms/__new - local.tee $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - call $~lib/object/Object#constructor - local.tee $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $3 - i32.const -65536 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - i32.store - br $__inlined_func$assembly/interpreter/dJump$24 - end - local.get $3 - i32.const 1 - i32.and - i32.const 1 - local.get $3 - select - br_if $folding-inner11 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $4 - i32.store offset=4 - local.get $3 - i32.const 1 - i32.shr_u - i32.const 1 - i32.sub - local.tee $3 - local.get $4 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.ge_u - br_if $folding-inner11 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $1 - i32.store offset=4 - local.get $1 - local.get $3 - call $~lib/staticarray/StaticArray#__get - local.tee $2 - i64.const 4294967296 - i64.ge_u - br_if $folding-inner11 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $2 - i64.store32 offset=4 - br $__inlined_func$assembly/interpreter/dJump$24 - end - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 2 - i32.store - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - local.tee $1 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.load - i32.const 1 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 0 - i32.store offset=20 - br $folding-inner4 - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load - i32.const 2 - i32.eq - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=12 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $1 - i32.load offset=4 - i32.const 0 - call $assembly/interpreter/branch - local.tee $1 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load8_u - i32.eqz - br_if $folding-inner1 - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load offset=12 - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - local.get $1 - local.get $3 - i32.load offset=4 - call $assembly/interpreter/branch - local.tee $1 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.load8_u - i32.eqz - br_if $folding-inner1 - br $folding-inner3 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=12 - i32.const 3 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 3 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $0 - local.get $3 - i32.load offset=16 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=16 - i32.const 1 - i32.add - local.get $5 - i32.add - i32.store offset=28 - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=12 - i32.const 1 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - i64.const 1 - call $assembly/gas/GasCounter#sub@override - drop - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=16 - i32.const 65536 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store offset=20 - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 2 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $0 - local.get $3 - i32.load offset=16 - i32.store offset=24 - end - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=12 - i32.const 2 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - i64.const 1 - call $assembly/gas/GasCounter#sub@override - drop - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=12 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $0 - local.get $3 - i32.load offset=16 - i32.store offset=24 - br $folding-inner5 - end - i32.const 19728 - i32.const 19776 - i32.const 171 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - local.get $0 - i32.load offset=16 - local.get $5 - i32.const 1 - i32.add - i32.add - i32.store offset=16 - br $folding-inner4 - end - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 4 - i32.store offset=20 - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.const 1 - i32.store offset=20 - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - i32.load offset=4 - i32.store offset=16 - end - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 1 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-debugger/nextStep (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 69 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - call $assembly/interpreter/Interpreter#nextStep - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $assembly/api-debugger/nSteps (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 77 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=4 - i32.const 1 - local.set $2 - loop $for-loop|0 - local.get $0 - local.get $3 - i32.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/interpreter/Interpreter#nextStep - local.tee $2 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - ) - (func $assembly/api-debugger/getProgramCounter (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 94 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/setNextProgramCounter (param $0 i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 102 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - local.get $0 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/getStatus (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 1 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 110 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=20 - i32.const 255 - i32.and - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/getExitArg (result i32) - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const -1 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 118 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - i32.load offset=24 - local.tee $0 - i32.eqz - if - i32.const -1 - local.set $0 - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/api-debugger/getGasLeft (result i64) - (local $0 i32) - (local $1 i64) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - i64.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 126 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $0 - i32.store offset=8 - local.get $0 - call $assembly/gas/GasCounter#get@override - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/setGasLeft (param $0 i64) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api-debugger/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 132 - i32.const 30 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=12 - local.tee $1 - i32.store offset=8 - local.get $1 - local.get $0 - call $assembly/gas/GasCounter#set@override - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/getRegister (param $0 i32) (result i64) - (local $1 i64) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - i64.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 141 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - local.tee $2 - i32.store offset=8 - local.get $2 - local.get $0 - i32.const 255 - i32.and - call $~lib/staticarray/StaticArray#__get - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/setRegister (param $0 i32) (param $1 i64) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api-debugger/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 149 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load offset=4 - local.tee $2 - i32.store offset=8 - local.get $2 - local.get $0 - i32.const 255 - i32.and - local.get $1 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/getRegisters (result i32) - (local $0 i32) - (local $1 i32) - (local $2 i64) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 104 - call $~lib/typedarray/Uint8Array#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - i32.const 1 - global.set $~argumentsLength - local.get $3 - call $~lib/typedarray/Uint8Array#fill@varargs - local.tee $4 - i32.store offset=4 - global.get $assembly/api-debugger/interpreter - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 159 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.store offset=12 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=4 - local.tee $0 - i32.store - local.get $1 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray#__get - local.set $2 - i32.const 0 - local.set $0 - loop $for-loop|1 - local.get $0 - i32.const 8 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $1 - i32.const 3 - i32.shl - local.get $0 - i32.add - local.get $2 - i64.const 255 - i64.and - i32.wrap_i64 - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i64.const 8 - i64.shr_u - local.set $2 - local.get $0 - i32.const 1 - i32.add - local.set $0 - br $for-loop|1 - end - end - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/api-debugger/getPageDump (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $assembly/api-debugger/interpreter - i32.eqz - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 184 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.tee $1 - i32.store - block $__inlined_func$assembly/memory/Memory#pageDump$2506 - local.get $1 - local.get $0 - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - local.set $0 - br $__inlined_func$assembly/memory/Memory#pageDump$2506 - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.tee $1 - i32.store offset=8 - local.get $1 - local.get $0 - call $"~lib/map/Map#get" - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $0 - i32.store - local.get $0 - call $assembly/memory-page/RawPage#get:data - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - end - local.get $0 - i32.store offset=16 - local.get $0 - i32.eqz - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - i32.const 4096 - call $~lib/typedarray/Uint8Array#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 1 - global.set $~argumentsLength - local.get $0 - call $~lib/typedarray/Uint8Array#fill@varargs - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-debugger/getMemory (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - block $folding-inner0 - global.get $assembly/api-debugger/interpreter - i32.eqz - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 197 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - call $~lib/typedarray/Uint8Array#constructor - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.tee $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - block $__inlined_func$assembly/memory/Memory#bytesRead$25 (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - loop $while-continue|0 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.sub - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.const 1 - local.get $0 - call $assembly/memory/Memory#getPage - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load - local.tee $4 - i32.store - local.get $4 - i32.load8_u - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$assembly/memory/Memory#bytesRead$25 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.load offset=8 - local.tee $7 - local.get $1 - i32.add - i32.const 4096 - i32.ge_u - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - i32.const 4096 - local.get $6 - i32.load offset=8 - i32.sub - local.set $1 - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $6 - i32.store offset=8 - local.get $6 - call $assembly/memory-page/RawPage#get:data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $7 - local.get $1 - local.get $7 - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $4 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $5 - local.get $4 - local.get $2 - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $1 - local.get $2 - i32.add - local.set $2 - local.get $0 - local.get $1 - i32.add - local.set $0 - br $while-continue|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $assembly/memory/NO_PAGE_FAULT - end - local.tee $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $0 - i32.load8_u - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-utils/prepareProgram (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (result i32) - (local $7 i32) - (local $8 i64) - global.get $~lib/memory/__stack_pointer - i32.const 48 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 48 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - call $assembly/program/liftBytes - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.tee $7 - i32.store offset=8 - local.get $1 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - call $assembly/program/extractCodeAndMetadata - local.tee $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - end - local.get $0 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - call $assembly/program/deblob - local.tee $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - call $assembly/memory/MemoryBuilder#constructor - local.tee $1 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $1 - local.get $4 - local.get $5 - call $assembly/api-internal/buildMemory - local.tee $2 - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 13 - call $~lib/staticarray/StaticArray#constructor - local.tee $4 - i32.store offset=36 - i32.const 0 - local.set $1 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - local.get $1 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $1 - local.get $3 - i32.load offset=12 - i32.ge_u - if - i32.const 1504 - i32.const 9152 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=4 - local.get $1 - i32.const 3 - i32.shl - i32.add - i64.load - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - local.get $1 - local.get $8 - call $~lib/staticarray/StaticArray#__set - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $2 - local.get $4 - call $assembly/spi/StandardProgram#constructor - local.tee $0 - i32.store offset=40 - br $folding-inner1 - end - local.get $0 - i32.const 1 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=28 - local.get $6 - call $assembly/program/liftBytes - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=24 - local.get $2 - local.get $1 - call $assembly/spi/decodeSpi - local.tee $0 - i32.store offset=44 - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - i32.const 19984 - i32.store - local.get $0 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=24 - i32.const 19984 - local.get $0 - call $~lib/string/String#concat - i32.const 20032 - i32.const 81 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=24 - local.get $0 - local.get $7 - i32.store - local.get $0 - local.get $7 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 48 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $assembly/gas-costs/computeGasCosts (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - local.set $3 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.const 57 - call $~lib/rt/itcms/__new - local.tee $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - i32.const 16 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $5 - local.get $6 - i32.store - local.get $5 - local.get $6 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - i32.const 48 - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $5 - local.get $6 - i32.store offset=8 - local.get $5 - local.get $6 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 4 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - loop $for-loop|0 - local.get $2 - local.get $3 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $4 - i32.store - local.get $4 - local.get $2 - call $assembly/program/Mask#isInstruction - i32.eqz - if - i32.const 15536 - i32.const 20096 - i32.const 16 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $4 - i32.store - local.get $4 - local.get $2 - call $~lib/typedarray/Uint8Array#__get - local.set $4 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $6 - i32.store - local.get $4 - local.get $6 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $6 - i32.store - local.get $6 - local.get $4 - call $~lib/array/Array#__get - end - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $6 - i32.store - local.get $6 - local.get $2 - call $assembly/program/BasicBlocks#isStart - if - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i32.load - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $5 - local.get $6 - local.get $1 - call $"~lib/map/Map#set" - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 54 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - call $~lib/object/Object#constructor - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $2 - i32.store - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $1 - i64.load offset=8 - local.get $4 - i64.load offset=8 - i64.add - i64.store offset=8 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $4 - i32.store - local.get $4 - local.get $2 - call $assembly/program/Mask#skipBytesToNextInstruction - local.get $2 - i32.add - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - i32.load - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $5 - local.get $0 - local.get $1 - call $"~lib/map/Map#set" - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-utils/getGasCosts (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 3 - i32.const 56 - i32.const 19856 - call $~lib/rt/__newArray - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 19888 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - i32.const 0 - i32.const 2 - i32.const 51 - i32.const 19920 - call $~lib/rt/__newArray - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 19952 - call $~lib/rt/__newArray - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $1 - local.get $2 - local.get $0 - local.get $4 - local.get $5 - local.get $6 - local.get $8 - call $assembly/api-utils/prepareProgram - local.tee $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=16 - local.tee $0 - i32.store offset=4 - local.get $0 - call $assembly/gas-costs/computeGasCosts - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=8 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=16 - local.set $0 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 55 - call $~lib/rt/itcms/__new - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store - local.get $4 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.store offset=12 - local.get $0 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9152 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - local.get $0 - local.get $0 - i32.const 8 - i32.le_u - select - i32.const 2 - i32.shl - local.tee $2 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $4 - local.get $5 - i32.store - local.get $4 - local.get $5 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - i32.const 0 - local.set $2 - loop $for-loop|0 - local.get $0 - local.get $3 - i32.gt_s - if - local.get $1 - local.get $3 - i32.const 12 - i32.mul - i32.add - local.tee $5 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load offset=4 - local.tee $5 - i32.store offset=8 - local.get $4 - local.get $2 - local.get $5 - call $~lib/array/Array#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $2 - call $~lib/array/Array#set:length - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-utils/disassemble~anonymous|0 (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $1 - i32.const 255 - i32.and - i32.const 16 - call $~lib/util/number/utoa32 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16080 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const -2 - i32.and - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16080 - i32.store - block $__inlined_func$~lib/string/String#padStart$2544 - i32.const 16076 - i32.load - i32.const -2 - i32.and - local.tee $2 - i32.eqz - local.get $5 - i32.const 4 - i32.gt_u - i32.or - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#padStart$2544 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store offset=4 - i32.const 4 - local.get $5 - i32.sub - local.tee $4 - local.get $2 - i32.gt_u - if - local.get $4 - local.get $4 - i32.const 2 - i32.sub - local.get $2 - i32.div_u - local.get $2 - i32.mul - local.tee $7 - i32.sub - local.set $8 - loop $while-continue|0 - local.get $6 - local.get $7 - i32.lt_u - if - local.get $3 - local.get $6 - i32.add - i32.const 16080 - local.get $2 - memory.copy - local.get $2 - local.get $6 - i32.add - local.set $6 - br $while-continue|0 - end - end - local.get $3 - local.get $7 - i32.add - i32.const 16080 - local.get $8 - memory.copy - else - local.get $3 - i32.const 16080 - local.get $4 - memory.copy - end - local.get $3 - local.get $4 - i32.add - local.get $1 - local.get $5 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - local.set $1 - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - call $~lib/string/String.__concat - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-utils/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 3 - i32.const 56 - i32.const 20160 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 49 - i32.const 20192 - call $~lib/rt/__newArray - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - i32.const 0 - i32.const 2 - i32.const 51 - i32.const 20224 - call $~lib/rt/__newArray - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - i32.const 0 - i32.const 0 - i32.const 27 - i32.const 20256 - call $~lib/rt/__newArray - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $1 - local.get $2 - local.get $0 - local.get $5 - local.get $6 - local.get $7 - local.get $8 - call $assembly/api-utils/prepareProgram - local.tee $1 - i32.store offset=20 - i32.const 15504 - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=24 - local.get $2 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 20288 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 20288 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 20336 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 20288 - i32.const 20336 - call $~lib/string/String.__concat - local.tee $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 20368 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=16 - i32.const 15504 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 20368 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - i32.load offset=4 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - local.set $7 - loop $for-loop|0 - local.get $3 - local.get $7 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $3 - local.get $6 - i32.add - i32.load8_u - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - i32.const 4 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $8 - local.get $3 - local.get $5 - i32.const 20368 - i32.load - call_indirect (type $7) - local.tee $2 - i32.store offset=8 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $0 - local.get $2 - call $~lib/string/String.__concat - local.tee $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 20400 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 20400 - call $~lib/string/String.__concat - local.tee $0 - i32.store offset=24 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=16 - local.tee $1 - i32.store offset=8 - local.get $1 - call $assembly/api-internal/getAssembly - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - call $~lib/string/String.__concat - local.tee $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/util/string/joinIntegerArray (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $1 - i32.const 1 - i32.sub - local.tee $4 - i32.const 0 - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15504 - return - end - local.get $4 - i32.eqz - if - local.get $0 - i64.load - i32.const 10 - call $~lib/util/number/utoa64 - local.set $0 - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - i32.const 17824 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 17820 - i32.load - i32.const 1 - i32.shr_u - local.tee $5 - i32.const 20 - i32.add - local.get $4 - i32.mul - i32.const 20 - i32.add - local.tee $6 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store offset=4 - loop $for-loop|0 - local.get $3 - local.get $4 - i32.lt_s - if - local.get $1 - local.get $2 - i32.const 1 - i32.shl - i32.add - local.get $0 - local.get $3 - i32.const 3 - i32.shl - i32.add - i64.load - call $~lib/util/number/itoa_buffered - local.get $2 - i32.add - local.set $2 - local.get $5 - if - local.get $1 - local.get $2 - i32.const 1 - i32.shl - i32.add - i32.const 17824 - local.get $5 - i32.const 1 - i32.shl - memory.copy - local.get $2 - local.get $5 - i32.add - local.set $2 - end - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $for-loop|0 - end - end - local.get $6 - local.get $1 - local.get $2 - i32.const 1 - i32.shl - i32.add - local.get $0 - local.get $4 - i32.const 3 - i32.shl - i32.add - i64.load - call $~lib/util/number/itoa_buffered - local.get $2 - i32.add - local.tee $2 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.gt_s - select - local.tee $2 - local.get $1 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 1 - i32.shr_u - local.tee $1 - local.get $1 - local.get $2 - i32.gt_s - select - local.tee $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.le_s - select - i32.const 1 - i32.shl - local.set $3 - block $__inlined_func$~lib/string/String#substring$2545 - local.get $2 - i32.const 0 - local.get $2 - i32.const 0 - i32.ge_s - select - i32.const 1 - i32.shl - local.tee $2 - local.get $3 - i32.sub - local.tee $4 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 15504 - local.set $0 - br $__inlined_func$~lib/string/String#substring$2545 - end - local.get $3 - i32.eqz - local.get $2 - local.get $1 - i32.const 1 - i32.shl - i32.eq - i32.and - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - br $__inlined_func$~lib/string/String#substring$2545 - end - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store offset=4 - local.get $1 - local.get $0 - local.get $3 - i32.add - local.get $4 - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - local.set $0 - end - br $folding-inner1 - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/staticarray/StaticArray#join (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 17824 - i32.store - local.get $0 - local.get $1 - call $~lib/util/string/joinIntegerArray - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/api-internal/executeProgram~anonymous|0 (param $0 i64) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 20336 - i32.store - local.get $0 - i32.const 16 - call $~lib/util/number/utoa64 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - i32.const 20336 - local.get $1 - call $~lib/string/String#concat - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#map<~lib/string/String> (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i64) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - local.tee $5 - i32.const 2 - i32.const 61 - i32.const 0 - call $~lib/rt/__newArray - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.load offset=4 - local.set $6 - loop $for-loop|0 - local.get $2 - local.get $5 - i32.lt_s - if - local.get $0 - local.get $2 - i32.const 3 - i32.shl - i32.add - i64.load - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - i32.const 3 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - local.get $7 - local.get $2 - local.get $0 - local.get $1 - i32.load - call_indirect (type $17) - local.tee $4 - i32.store offset=8 - local.get $6 - local.get $2 - i32.const 2 - i32.shl - i32.add - local.get $4 - i32.store - local.get $3 - local.get $4 - i32.const 1 - call $~lib/rt/itcms/__link - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/array/Array<~lib/string/String>#join (param $0 i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 17824 - i32.store - i32.const 17824 - call $~lib/util/string/joinStringArray - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/resolveArguments (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i64) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner6 - block $folding-inner5 - block $folding-inner4 - block $folding-inner3 - block $folding-inner2 - block $folding-inner1 - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - local.get $2 - call $assembly/program/decodeArguments - local.tee $2 - i32.store offset=4 - local.get $2 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 0 - return - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.const 63 - call $~lib/rt/itcms/__new - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - call $~lib/object/Object#constructor - local.tee $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i64.const 0 - i64.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - call $assembly/arguments/Args#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $6 - local.get $1 - i32.store offset=32 - local.get $6 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i32.store offset=32 - local.get $6 - local.get $2 - i32.const 0 - call $~lib/rt/itcms/__link - block $case13|0 - block $case12|0 - block $case11|0 - block $case8|0 - block $case5|0 - block $case4|0 - block $case2|0 - local.get $0 - br_table $folding-inner6 $folding-inner1 $case2|0 $folding-inner1 $case4|0 $case5|0 $folding-inner3 $folding-inner3 $case8|0 $folding-inner4 $folding-inner4 $case11|0 $case12|0 $case13|0 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s - i64.store - br $folding-inner2 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - br $folding-inner2 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $2 - i64.load32_u - i64.const 32 - i64.shl - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $4 - local.get $2 - i64.load32_u offset=4 - i64.add - i64.store offset=8 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=8 - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=12 - i64.store offset=24 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=8 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=16 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - i32.const 17888 - i32.store - local.get $0 - call $~lib/number/I32#toString - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - i32.const 17888 - local.get $0 - call $~lib/string/String#concat - i32.const 21008 - i32.const 332 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s - i64.store - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=4 - i64.store offset=8 - br $folding-inner6 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=4 - i64.store offset=8 - br $folding-inner5 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=16 - local.get $6 - local.get $3 - i32.const 12 - local.get $2 - i64.load32_u offset=4 - local.tee $4 - i32.wrap_i64 - local.get $4 - i64.const 13 - i64.ge_u - select - call $~lib/staticarray/StaticArray#__get - i64.store offset=8 - end - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - local.get $6 - local.get $2 - i64.load32_s offset=8 - i64.store offset=16 - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - ) - (func $assembly/api-internal/getOutputChunks (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 2 - i32.const 51 - i32.const 21408 - call $~lib/rt/__newArray - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.load offset=8 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.load offset=16 - local.set $8 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 38 - call $~lib/rt/itcms/__new - local.tee $9 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store - local.get $9 - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - i32.store offset=12 - local.get $8 - i32.const 268435455 - i32.gt_u - if - i32.const 9200 - i32.const 9152 - i32.const 70 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - local.get $8 - local.get $8 - i32.const 8 - i32.le_u - select - i32.const 2 - i32.shl - local.tee $10 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $9 - local.get $5 - i32.store - local.get $9 - local.get $5 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $5 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $10 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $8 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - loop $for-loop|0 - local.get $2 - local.get $8 - i32.lt_s - if - local.get $7 - local.get $2 - i32.const 12 - i32.mul - i32.add - local.tee $5 - i32.load offset=8 - i32.const 1 - i32.and - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $1 - local.get $5 - i32.load - call $~lib/array/Array#__set - local.get $1 - i32.const 1 - i32.add - local.set $1 - end - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $1 - call $~lib/array/Array#set:length - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - i32.const 0 - local.set $1 - loop $for-loop|00 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/array/Array#get:length - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $4 - call $~lib/array/Array#__get - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - local.get $5 - call $"~lib/map/Map#get" - local.tee $6 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $2 - i32.store offset=4 - local.get $2 - i32.load offset=4 - if - i32.const 0 - local.set $2 - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - local.get $7 - call $assembly/memory-page/RawPage#get:data - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - local.tee $7 - i32.store offset=8 - local.get $7 - call $assembly/memory-page/RawPage#get:data - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $2 - call $~lib/typedarray/Uint8Array#__get - local.tee $7 - if - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $8 - i32.store offset=4 - local.get $8 - local.get $7 - call $~lib/array/Array#push - else - global.get $~lib/memory/__stack_pointer - call $assembly/api-internal/InitialChunk#constructor - local.tee $1 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - local.get $5 - i32.const 12 - i32.shl - local.get $2 - i32.add - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 1 - i32.const 0 - i32.const 27 - i32.const 0 - call $~lib/rt/__newArray - local.tee $8 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.load offset=12 - i32.eqz - if - local.get $8 - i32.const 1 - i32.const 0 - i32.const 1 - call $~lib/array/ensureCapacity - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - i32.store offset=12 - end - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.load offset=4 - local.get $7 - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $1 - local.get $8 - i32.store offset=4 - local.get $1 - local.get $8 - i32.const 0 - call $~lib/rt/itcms/__link - end - else - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - call $~lib/array/Array#push - i32.const 0 - local.set $1 - end - end - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|1 - end - end - end - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|00 - end - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $3 - local.get $1 - call $~lib/array/Array#push - end - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-internal/executeProgram (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 108 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 108 - memory.fill - i32.const 1 - local.set $2 - loop $for-loop|0 - block $for-break0 - local.get $2 - i32.eqz - if - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 17824 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - call $~lib/staticarray/StaticArray#join - local.tee $2 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 20528 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 20532 - local.get $2 - i32.store - i32.const 20528 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 20528 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=8 - i32.const 20528 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 20592 - i32.store offset=20 - local.get $3 - i32.const 20592 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 17824 - i32.store offset=8 - local.get $3 - call $~lib/array/Array<~lib/string/String>#join - local.tee $2 - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 20560 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 20564 - local.get $2 - i32.store - i32.const 20560 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 20560 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=8 - i32.const 20560 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 20624 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $0 - i32.load offset=20 - call $~lib/number/I32#toString - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 20624 - local.get $2 - call $~lib/string/String#concat - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 20688 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $0 - i32.load offset=24 - i32.const 10 - call $~lib/util/number/utoa32 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - i32.const 20688 - local.get $1 - call $~lib/string/String#concat - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/console/console.log - end - br $for-break0 - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 20736 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $0 - i32.load offset=16 - i32.const 10 - call $~lib/util/number/utoa32 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 20736 - local.get $2 - call $~lib/string/String#concat - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 20768 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $2 - i32.store offset=12 - local.get $2 - call $assembly/gas/GasCounter#get@override - call $~lib/util/number/itoa64 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 20768 - local.get $2 - call $~lib/string/String#concat - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 20800 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $0 - i32.load offset=20 - call $~lib/number/I32#toString - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 20800 - local.get $2 - call $~lib/string/String#concat - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 20432 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 17824 - i32.store offset=20 - local.get $2 - call $~lib/staticarray/StaticArray#join - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 20432 - local.get $2 - call $~lib/string/String#concat - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - i32.const 20432 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $2 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 20848 - i32.store offset=32 - local.get $2 - i32.const 20848 - call $~lib/staticarray/StaticArray#map<~lib/string/String> - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 17824 - i32.store offset=20 - local.get $2 - call $~lib/array/Array<~lib/string/String>#join - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 20432 - local.get $2 - call $~lib/string/String#concat - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/console/console.log - end - local.get $1 - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load offset=16 - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load - local.tee $3 - i32.store - local.get $3 - call $~lib/typedarray/Uint8Array#get:length - local.get $2 - i32.gt_u - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.load - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=16 - call $~lib/typedarray/Uint8Array#__get - else - i32.const 0 - end - local.set $2 - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $3 - i32.store - local.get $2 - local.get $3 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $~lib/memory/__stack_pointer - global.get $assembly/instructions/INSTRUCTIONS - local.tee $3 - i32.store - local.get $3 - local.get $2 - call $~lib/array/Array#__get - end - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.load offset=4 - local.tee $4 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $4 - local.get $0 - i32.load offset=16 - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load - local.tee $5 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=44 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.const 255 - i32.and - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $2 - i32.store offset=48 - global.get $~lib/memory/__stack_pointer - i32.const 20960 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - i32.const 20964 - local.get $5 - i32.store - i32.const 20960 - local.get $5 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 20960 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 20972 - local.get $2 - i32.store - i32.const 20960 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 20960 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=8 - i32.const 20960 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load - local.tee $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.load - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $0 - i32.load offset=16 - i32.const 1 - i32.add - local.set $6 - i32.const 1 - global.set $~argumentsLength - local.get $5 - local.get $6 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $6 - i32.store offset=4 - local.get $5 - local.get $4 - local.get $6 - call $assembly/program/resolveArguments - local.tee $8 - i32.store offset=52 - local.get $8 - if - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i64.load - call $~lib/util/number/itoa64 - local.tee $2 - i32.store offset=56 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load offset=32 - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $3 - i32.store offset=60 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i64.load - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $4 - i32.store offset=64 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i64.load offset=8 - call $~lib/util/number/itoa64 - local.tee $5 - i32.store offset=68 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load offset=32 - local.tee $6 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.load offset=4 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $6 - i32.store offset=72 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i64.load offset=8 - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $9 - i32.store offset=76 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i64.load offset=16 - call $~lib/util/number/itoa64 - local.tee $10 - i32.store offset=80 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load offset=32 - local.tee $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.load offset=8 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $7 - i32.store offset=84 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i64.load offset=16 - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $11 - i32.store offset=88 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i64.load offset=24 - call $~lib/util/number/itoa64 - local.tee $12 - i32.store offset=92 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load offset=32 - local.tee $13 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.load offset=12 - i32.const 10 - call $~lib/util/number/utoa32 - local.tee $13 - i32.store offset=96 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i64.load offset=24 - i32.const 16 - call $~lib/util/number/utoa64 - local.tee $8 - i32.store offset=100 - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - i32.const 21220 - local.get $2 - i32.store - i32.const 21216 - local.get $2 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - i32.const 21228 - local.get $3 - i32.store - i32.const 21216 - local.get $3 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - i32.const 21236 - local.get $4 - i32.store - i32.const 21216 - local.get $4 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - i32.const 21244 - local.get $5 - i32.store - i32.const 21216 - local.get $5 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - i32.const 21252 - local.get $6 - i32.store - i32.const 21216 - local.get $6 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - i32.const 21260 - local.get $9 - i32.store - i32.const 21216 - local.get $9 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - i32.const 21268 - local.get $10 - i32.store - i32.const 21216 - local.get $10 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - i32.const 21276 - local.get $7 - i32.store - i32.const 21216 - local.get $7 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=8 - i32.const 21284 - local.get $11 - i32.store - i32.const 21216 - local.get $11 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - i32.const 21292 - local.get $12 - i32.store - i32.const 21216 - local.get $12 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - i32.const 21300 - local.get $13 - i32.store - i32.const 21216 - local.get $13 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - i32.const 21308 - local.get $8 - i32.store - i32.const 21216 - local.get $8 - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 21216 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 15504 - i32.store offset=8 - i32.const 21216 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/console/console.log - end - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/interpreter/Interpreter#nextStep - local.set $2 - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 59 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - call $~lib/object/Object#constructor - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const -1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - i32.const 0 - i32.const 3 - i32.const 56 - i32.const 21344 - call $~lib/rt/__newArray - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $2 - local.get $3 - i32.store offset=4 - local.get $2 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - i32.const 0 - i32.const 2 - i32.const 51 - i32.const 21376 - call $~lib/rt/__newArray - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $2 - local.get $3 - i32.store offset=12 - local.get $2 - local.get $3 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i64.const 0 - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=104 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=20 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=4 - local.tee $1 - i32.store offset=8 - i32.const 1 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 20 - i32.sub - i32.load offset=16 - i32.const 3 - i32.shr_u - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.tee $3 - i32.const 0 - local.get $3 - i32.const 0 - i32.gt_s - select - local.tee $3 - i32.const 3 - i32.const 56 - i32.const 0 - call $~lib/rt/__newArray - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.load offset=4 - local.get $1 - local.get $3 - i32.const 3 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $2 - local.get $4 - i32.store offset=4 - local.get $2 - local.get $4 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=16 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store offset=4 - local.get $2 - local.get $1 - call $assembly/gas/GasCounter#get@override - i64.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=8 - local.tee $1 - i32.store offset=8 - local.get $1 - call $assembly/api-internal/getOutputChunks - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $2 - local.get $1 - i32.store offset=12 - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $2 - local.get $0 - i32.load offset=24 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 108 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $assembly/api-utils/runProgram (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) (param $4 i32) (result i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=16 - local.tee $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=20 - local.tee $7 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=24 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 60 - call $~lib/rt/itcms/__new - local.tee $8 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $8 - local.get $5 - i32.store offset=16 - local.get $8 - local.get $5 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $8 - local.get $7 - i32.store offset=20 - local.get $8 - local.get $7 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $8 - local.get $0 - i32.store offset=24 - local.get $8 - local.get $0 - i32.const 0 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $1 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load offset=16 - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load offset=24 - local.tee $2 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.load offset=20 - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $2 - local.get $5 - call $assembly/interpreter/Interpreter#constructor - local.tee $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $4 - i32.store8 offset=32 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $0 - local.get $8 - i32.load - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $2 - local.get $8 - i64.load offset=8 - call $assembly/gas/GasCounter#set@override - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $3 - call $assembly/api-internal/executeProgram - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $~lib/object/Object#constructor (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/rt/__newArray (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - local.get $1 - i32.shl - local.tee $5 - i32.const 1 - call $~lib/rt/itcms/__new - local.set $1 - local.get $3 - if - local.get $1 - local.get $3 - local.get $5 - memory.copy - end - local.get $1 - i32.store - i32.const 16 - local.get $2 - call $~lib/rt/itcms/__new - local.tee $2 - local.get $1 - i32.store - local.get $2 - local.get $1 - i32.const 0 - call $~lib/rt/itcms/__link - local.get $2 - local.get $1 - i32.store offset=4 - local.get $2 - local.get $5 - i32.store offset=8 - local.get $2 - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/staticarray/StaticArray#constructor (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i32.const 1073741820 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 23 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/arraybuffer/ArrayBuffer#constructor (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i32.const 1073741820 - i32.gt_u - if - i32.const 9200 - i32.const 9248 - i32.const 52 - i32.const 43 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/util/number/utoa32 (param $0 i32) (param $1 i32) (result i32) - (local $2 i32) - (local $3 i64) - (local $4 i64) - (local $5 i64) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $1 - i32.const 2 - i32.lt_s - local.get $1 - i32.const 36 - i32.gt_s - i32.or - if - i32.const 15888 - i32.const 16016 - i32.const 350 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 16080 - return - end - local.get $1 - i32.const 10 - i32.eq - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 100000 - i32.lt_u - if (result i32) - local.get $0 - i32.const 100 - i32.lt_u - if (result i32) - local.get $0 - i32.const 10 - i32.ge_u - i32.const 1 - i32.add - else - local.get $0 - i32.const 10000 - i32.ge_u - i32.const 3 - i32.add - local.get $0 - i32.const 1000 - i32.ge_u - i32.add - end - else - local.get $0 - i32.const 10000000 - i32.lt_u - if (result i32) - local.get $0 - i32.const 1000000 - i32.ge_u - i32.const 6 - i32.add - else - local.get $0 - i32.const 1000000000 - i32.ge_u - i32.const 8 - i32.add - local.get $0 - i32.const 100000000 - i32.ge_u - i32.add - end - end - local.tee $1 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - local.get $2 - local.get $0 - local.get $1 - call $~lib/util/number/utoa32_dec_lut - else - local.get $1 - i32.const 16 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 31 - local.get $0 - i32.clz - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.tee $1 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - local.get $0 - i64.extend_i32_u - local.set $3 - loop $while-continue|0 - local.get $1 - i32.const 2 - i32.ge_u - if - local.get $2 - local.get $1 - i32.const 2 - i32.sub - local.tee $1 - i32.const 1 - i32.shl - i32.add - local.get $3 - i32.wrap_i64 - i32.const 255 - i32.and - i32.const 2 - i32.shl - i32.const 16512 - i32.add - i32.load - i32.store - local.get $3 - i64.const 8 - i64.shr_u - local.set $3 - br $while-continue|0 - end - end - local.get $1 - i32.const 1 - i32.and - if - local.get $2 - local.get $3 - i32.wrap_i64 - i32.const 6 - i32.shl - i32.const 16512 - i32.add - i32.load16_u - i32.store16 - end - else - global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2338 (result i32) - local.get $0 - i64.extend_i32_u - local.set $4 - local.get $1 - i32.popcnt - i32.const 1 - i32.eq - if - i32.const 63 - local.get $4 - i64.clz - i32.wrap_i64 - i32.sub - i32.const 31 - local.get $1 - i32.clz - i32.sub - i32.div_u - i32.const 1 - i32.add - br $__inlined_func$~lib/util/number/ulog_base$2338 - end - local.get $1 - i64.extend_i32_s - local.tee $5 - local.set $3 - i32.const 1 - local.set $2 - loop $while-continue|01 - local.get $3 - local.get $4 - i64.le_u - if - local.get $4 - local.get $3 - i64.div_u - local.set $4 - local.get $3 - local.get $3 - i64.mul - local.set $3 - local.get $2 - i32.const 1 - i32.shl - local.set $2 - br $while-continue|01 - end - end - loop $while-continue|1 - local.get $4 - i64.const 0 - i64.ne - if - local.get $4 - local.get $5 - i64.div_u - local.set $4 - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $while-continue|1 - end - end - local.get $2 - i32.const 1 - i32.sub - end - local.tee $6 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - local.get $2 - local.get $0 - i64.extend_i32_u - local.get $6 - local.get $1 - call $~lib/util/number/utoa64_any_core - end - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/util/number/utoa64 (param $0 i64) (param $1 i32) (result i32) - (local $2 i64) - (local $3 i32) - (local $4 i64) - (local $5 i64) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $1 - i32.const 2 - i32.lt_s - local.get $1 - i32.const 36 - i32.gt_s - i32.or - if - i32.const 15888 - i32.const 16016 - i32.const 401 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $0 - i64.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 16080 - return - end - local.get $1 - i32.const 10 - i32.eq - if - local.get $0 - i64.const 4294967295 - i64.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.wrap_i64 - local.tee $1 - i32.const 100000 - i32.lt_u - if (result i32) - local.get $1 - i32.const 100 - i32.lt_u - if (result i32) - local.get $1 - i32.const 10 - i32.ge_u - i32.const 1 - i32.add - else - local.get $1 - i32.const 10000 - i32.ge_u - i32.const 3 - i32.add - local.get $1 - i32.const 1000 - i32.ge_u - i32.add - end - else - local.get $1 - i32.const 10000000 - i32.lt_u - if (result i32) - local.get $1 - i32.const 1000000 - i32.ge_u - i32.const 6 - i32.add - else - local.get $1 - i32.const 1000000000 - i32.ge_u - i32.const 8 - i32.add - local.get $1 - i32.const 100000000 - i32.ge_u - i32.add - end - end - local.tee $6 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - local.get $3 - local.get $1 - local.get $6 - call $~lib/util/number/utoa32_dec_lut - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i64.const 1000000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 1000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 100000000000 - i64.ge_u - i32.const 10 - i32.add - local.get $0 - i64.const 10000000000 - i64.ge_u - i32.add - else - local.get $0 - i64.const 100000000000000 - i64.ge_u - i32.const 13 - i32.add - local.get $0 - i64.const 10000000000000 - i64.ge_u - i32.add - end - else - local.get $0 - i64.const 100000000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 10000000000000000 - i64.ge_u - i32.const 16 - i32.add - else - local.get $0 - i64.const -8446744073709551616 - i64.ge_u - i32.const 18 - i32.add - local.get $0 - i64.const 1000000000000000000 - i64.ge_u - i32.add - end - end - local.tee $1 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - local.get $3 - local.get $0 - local.get $1 - call $~lib/util/number/utoa64_dec_lut - end - else - local.get $1 - i32.const 16 - i32.eq - if - global.get $~lib/memory/__stack_pointer - i32.const 63 - local.get $0 - i64.clz - i32.wrap_i64 - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.tee $1 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - loop $while-continue|0 - local.get $1 - i32.const 2 - i32.ge_u - if - local.get $3 - local.get $1 - i32.const 2 - i32.sub - local.tee $1 - i32.const 1 - i32.shl - i32.add - local.get $0 - i32.wrap_i64 - i32.const 255 - i32.and - i32.const 2 - i32.shl - i32.const 16512 - i32.add - i32.load - i32.store - local.get $0 - i64.const 8 - i64.shr_u - local.set $0 - br $while-continue|0 - end - end - local.get $1 - i32.const 1 - i32.and - if - local.get $3 - local.get $0 - i32.wrap_i64 - i32.const 6 - i32.shl - i32.const 16512 - i32.add - i32.load16_u - i32.store16 - end - else - global.get $~lib/memory/__stack_pointer - block $__inlined_func$~lib/util/number/ulog_base$2343 (result i32) - local.get $0 - local.set $2 - local.get $1 - i32.popcnt - i32.const 1 - i32.eq - if - i32.const 63 - local.get $0 - i64.clz - i32.wrap_i64 - i32.sub - i32.const 31 - local.get $1 - i32.clz - i32.sub - i32.div_u - i32.const 1 - i32.add - br $__inlined_func$~lib/util/number/ulog_base$2343 - end - local.get $1 - i64.extend_i32_s - local.tee $5 - local.set $4 - i32.const 1 - local.set $3 - loop $while-continue|01 - local.get $2 - local.get $4 - i64.ge_u - if - local.get $2 - local.get $4 - i64.div_u - local.set $2 - local.get $4 - local.get $4 - i64.mul - local.set $4 - local.get $3 - i32.const 1 - i32.shl - local.set $3 - br $while-continue|01 - end - end - loop $while-continue|1 - local.get $2 - i64.const 0 - i64.ne - if - local.get $2 - local.get $5 - i64.div_u - local.set $2 - local.get $3 - i32.const 1 - i32.add - local.set $3 - br $while-continue|1 - end - end - local.get $3 - i32.const 1 - i32.sub - end - local.tee $6 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $3 - i32.store - local.get $3 - local.get $0 - local.get $6 - local.get $1 - call $~lib/util/number/utoa64_any_core - end - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#constructor (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i32.const 134217727 - i32.gt_u - if - i32.const 9200 - i32.const 9312 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.const 3 - i32.shl - i32.const 14 - call $~lib/rt/itcms/__new - local.tee $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - ) - (func $~lib/util/number/itoa64 (param $0 i64) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $0 - i64.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - i32.const 16080 - return - end - i64.const 0 - local.get $0 - i64.sub - local.get $0 - local.get $0 - i64.const 63 - i64.shr_u - i32.wrap_i64 - i32.const 1 - i32.shl - local.tee $1 - select - local.tee $0 - i64.const 4294967295 - i64.le_u - if - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.wrap_i64 - local.tee $4 - i32.const 100000 - i32.lt_u - if (result i32) - local.get $4 - i32.const 100 - i32.lt_u - if (result i32) - local.get $4 - i32.const 10 - i32.ge_u - i32.const 1 - i32.add - else - local.get $4 - i32.const 10000 - i32.ge_u - i32.const 3 - i32.add - local.get $4 - i32.const 1000 - i32.ge_u - i32.add - end - else - local.get $4 - i32.const 10000000 - i32.lt_u - if (result i32) - local.get $4 - i32.const 1000000 - i32.ge_u - i32.const 6 - i32.add - else - local.get $4 - i32.const 1000000000 - i32.ge_u - i32.const 8 - i32.add - local.get $4 - i32.const 100000000 - i32.ge_u - i32.add - end - end - local.tee $3 - i32.const 1 - i32.shl - local.get $1 - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - local.get $1 - local.get $2 - i32.add - local.get $4 - local.get $3 - call $~lib/util/number/utoa32_dec_lut - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i64.const 1000000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 1000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 100000000000 - i64.ge_u - i32.const 10 - i32.add - local.get $0 - i64.const 10000000000 - i64.ge_u - i32.add - else - local.get $0 - i64.const 100000000000000 - i64.ge_u - i32.const 13 - i32.add - local.get $0 - i64.const 10000000000000 - i64.ge_u - i32.add - end - else - local.get $0 - i64.const 100000000000000000 - i64.lt_u - if (result i32) - local.get $0 - i64.const 10000000000000000 - i64.ge_u - i32.const 16 - i32.add - else - local.get $0 - i64.const -8446744073709551616 - i64.ge_u - i32.const 18 - i32.add - local.get $0 - i64.const 1000000000000000000 - i64.ge_u - i32.add - end - end - local.tee $3 - i32.const 1 - i32.shl - local.get $1 - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $2 - i32.store - local.get $1 - local.get $2 - i32.add - local.get $0 - local.get $3 - call $~lib/util/number/utoa64_dec_lut - end - local.get $1 - if - local.get $2 - i32.const 45 - i32.store16 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $export:assembly/api-internal/getAssembly (param $0 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/api-internal/getAssembly - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/program-build/wrapAsProgram (param $0 i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/program-build/buildMask - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i64.extend_i32_s - call $assembly/codec/encodeVarU32 - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - i32.const 2 - i32.add - local.get $2 - i32.add - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - local.get $2 - i32.add - call $~lib/typedarray/Uint8Array#constructor - local.tee $6 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 1 - i32.const 0 - call $~lib/typedarray/Uint8Array#__set - i32.const 2 - local.set $2 - loop $for-loop|0 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - local.get $4 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $6 - local.get $2 - local.get $5 - local.get $4 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - local.get $4 - i32.const 1 - i32.add - local.set $4 - br $for-loop|0 - end - end - loop $for-loop|1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $~lib/typedarray/Uint8Array#get:length - local.get $1 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=16 - local.get $6 - local.get $2 - local.get $0 - local.get $1 - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - local.get $1 - i32.const 1 - i32.add - local.set $1 - br $for-loop|1 - end - end - i32.const 0 - local.set $0 - loop $for-loop|2 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - local.get $0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $6 - local.get $2 - local.get $3 - local.get $0 - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $2 - i32.const 1 - i32.add - local.set $2 - local.get $0 - i32.const 1 - i32.add - local.set $0 - br $for-loop|2 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api-debugger/resetJAM@varargs (param $0 i32) (param $1 f64) (param $2 i64) (param $3 i32) (param $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 4 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - i32.const 0 - local.set $4 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $4 - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - call $assembly/program/liftBytes - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $assembly/program/extractCodeAndMetadata - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/program/liftBytes - end - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/program/liftBytes - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $0 - local.get $3 - call $assembly/spi/decodeSpi - local.tee $0 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=16 - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=24 - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=20 - local.tee $0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - local.get $4 - local.get $0 - call $assembly/interpreter/Interpreter#constructor - local.tee $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - i32.trunc_sat_f64_u - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $3 - i32.store - local.get $3 - local.get $2 - call $assembly/gas/GasCounter#set@override - global.get $assembly/api-debugger/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $3 - i32.store offset=28 - local.get $3 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 22 - i32.const 19 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.tee $3 - i32.store - local.get $3 - call $assembly/memory/Memory#free - end - local.get $0 - global.set $assembly/api-debugger/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api-debugger/resetGeneric@varargs (param $0 i32) (param $1 i32) (param $2 i64) (param $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 3 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - i32.const 0 - local.set $3 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $3 - if (result i32) - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=8 - local.get $0 - call $assembly/program/liftBytes - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - local.get $0 - call $assembly/program/extractCodeAndMetadata - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - i32.load - else - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/program/liftBytes - end - local.tee $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - call $assembly/program/deblob - local.tee $3 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 13 - call $~lib/staticarray/StaticArray#constructor - local.tee $0 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $0 - local.get $1 - call $assembly/api-debugger/fillRegisters - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - i32.const 2 - global.set $~argumentsLength - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner1 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - call $assembly/memory/MemoryBuilder#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 0 - call $assembly/memory/MemoryBuilder#build - local.tee $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - local.get $3 - local.get $0 - local.get $1 - call $assembly/interpreter/Interpreter#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.load offset=12 - local.tee $1 - i32.store - local.get $1 - local.get $2 - call $assembly/gas/GasCounter#set@override - global.get $assembly/api-debugger/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store offset=28 - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 38 - i32.const 19 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=8 - local.tee $1 - i32.store - local.get $1 - call $assembly/memory/Memory#free - end - local.get $0 - global.set $assembly/api-debugger/interpreter - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api-debugger/resetGenericWithMemory@varargs (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i64) (param $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 5 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - i32.const 0 - local.set $5 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $0 - local.get $1 - local.get $2 - local.get $3 - local.get $4 - local.get $5 - call $assembly/api-debugger/resetGenericWithMemory - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api-debugger/setRegisters (param $0 i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $assembly/api-debugger/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $1 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 176 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $1 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.load offset=4 - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store offset=12 - local.get $1 - local.get $0 - call $assembly/api-debugger/fillRegisters - end - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api-debugger/setMemory (param $0 i32) (param $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $assembly/api-debugger/interpreter - if - global.get $~lib/memory/__stack_pointer - global.get $assembly/api-debugger/interpreter - local.tee $3 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.eqz - if - i32.const 10512 - i32.const 19360 - i32.const 210 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $0 - i32.add - local.set $4 - local.get $0 - local.set $2 - loop $for-loop|0 - local.get $2 - local.get $4 - i32.lt_u - if - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.load offset=8 - local.tee $5 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $5 - local.get $2 - local.get $1 - local.get $2 - local.get $0 - i32.sub - call $~lib/typedarray/Uint8Array#__get - call $assembly/memory/Memory#setU8 - drop - local.get $2 - i32.const 1 - i32.add - local.set $2 - br $for-loop|0 - end - end - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) - (func $export:assembly/api-utils/getGasCosts (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - call $assembly/api-utils/getGasCosts - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api-utils/disassemble (param $0 i32) (param $1 i32) (param $2 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - call $assembly/api-utils/disassemble - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api-utils/prepareProgram (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (param $5 i32) (param $6 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - if - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=16 - local.get $0 - local.get $1 - local.get $2 - local.get $3 - local.get $4 - local.get $5 - local.get $6 - call $assembly/api-utils/prepareProgram - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $export:assembly/api-utils/runProgram@varargs (param $0 i32) (param $1 i64) (param $2 i32) (param $3 i32) (param $4 i32) (result i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - block $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 21812 - i32.lt_s - br_if $folding-inner0 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $4of4 - block $3of4 - block $2of4 - block $1of4 - block $0of4 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of4 $1of4 $2of4 $3of4 $4of4 $outOfRange - end - unreachable - end - i64.const 0 - local.set $1 - end - i32.const 0 - local.set $2 - end - i32.const 0 - local.set $3 - end - i32.const 0 - local.set $4 - end - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - local.get $1 - local.get $2 - local.get $3 - local.get $4 - call $assembly/api-utils/runProgram - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - return - end - i32.const 54608 - i32.const 54656 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - ) -) diff --git a/build/test.d.ts b/build/test.d.ts deleted file mode 100644 index 981d658..0000000 --- a/build/test.d.ts +++ /dev/null @@ -1,6 +0,0 @@ -/** Exported memory */ -export declare const memory: WebAssembly.Memory; -/** - * assembly/test-run/runAllTests - */ -export declare function runAllTests(): void; diff --git a/build/test.js b/build/test.js deleted file mode 100644 index 7e2eb90..0000000 --- a/build/test.js +++ /dev/null @@ -1,47 +0,0 @@ -async function instantiate(module, imports = {}) { - const adaptedImports = { - env: Object.setPrototypeOf({ - abort(message, fileName, lineNumber, columnNumber) { - // ~lib/builtins/abort(~lib/string/String | null?, ~lib/string/String | null?, u32?, u32?) => void - message = __liftString(message >>> 0); - fileName = __liftString(fileName >>> 0); - lineNumber = lineNumber >>> 0; - columnNumber = columnNumber >>> 0; - (() => { - // @external.js - throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`); - })(); - }, - "console.log"(text) { - // ~lib/bindings/dom/console.log(~lib/string/String) => void - text = __liftString(text >>> 0); - console.log(text); - }, - }, Object.assign(Object.create(globalThis), imports.env || {})), - }; - const { exports } = await WebAssembly.instantiate(module, adaptedImports); - const memory = exports.memory || imports.env.memory; - function __liftString(pointer) { - if (!pointer) return null; - const - end = pointer + new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> 1, - memoryU16 = new Uint16Array(memory.buffer); - let - start = pointer >>> 1, - string = ""; - while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024)); - return string + String.fromCharCode(...memoryU16.subarray(start, end)); - } - return exports; -} -export const { - memory, - runAllTests, -} = await (async url => instantiate( - await (async () => { - const isNodeOrBun = typeof process != "undefined" && process.versions != null && (process.versions.node != null || process.versions.bun != null); - if (isNodeOrBun) { return globalThis.WebAssembly.compile(await (await import("node:fs/promises")).readFile(url)); } - else { return await globalThis.WebAssembly.compileStreaming(globalThis.fetch(url)); } - })(), { - } -))(new URL("test.wasm", import.meta.url)); diff --git a/build/test.wasm b/build/test.wasm deleted file mode 100644 index 3af31ef035e968e99a8ce48aecc5f2952e201887..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 189870 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

J%xwjTRtbC&3yarPwt4J(T!#8`8L)0BM@RWZr?E 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 diff --git a/build/test.wasm.map b/build/test.wasm.map deleted file mode 100644 index f95b653..0000000 --- a/build/test.wasm.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"sources":["~lib/rt/common.ts","~lib/rt/tlsf.ts","~lib/shared/typeinfo.ts","~lib/rt/itcms.ts","assembly/arguments.ts","~lib/util/error.ts","~lib/shared/runtime.ts","~lib/util/number.ts","~lib/util/math.ts","~lib/util/string.ts","~lib/rt.ts","~lib/typedarray.ts","~lib/util/sort.ts","~lib/math.ts","~lib/builtins.ts","assembly/registers.ts","assembly/memory-page.ts","assembly/memory.ts","~lib/arraybuffer.ts","assembly/instructions/outcome.ts","assembly/instructions/bit.ts","assembly/instructions/utils.ts","~lib/staticarray.ts","~lib/polyfills.ts","assembly/instructions/bit.test.ts","~lib/util/hash.ts","~lib/map.ts","~lib/array.ts","assembly/test.ts","~lib/number.ts","~lib/string.ts","assembly/instructions/branch.ts","assembly/instructions/branch.test.ts","assembly/instructions/logic.ts","assembly/instructions/logic.test.ts","assembly/instructions/math.ts","assembly/instructions/math.test.ts","assembly/instructions/rot.ts","assembly/instructions/rot.test.ts","assembly/memory.test.ts","~lib/util/bytes.ts","~lib/console.ts","assembly/instructions/jump.ts","assembly/instructions/misc.ts","assembly/instructions/load.ts","assembly/instructions/mov.ts","assembly/instructions/set.ts","assembly/instructions/shift.ts","assembly/instructions/store.ts","assembly/instructions-exe.ts","assembly/codec.ts","assembly/instructions.ts","assembly/program.ts","assembly/program.test.ts","assembly/spi.ts","assembly/spi.test.ts","assembly/test-run.ts","~lib/function.ts"],"names":[],"mappings":"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","sourceRoot":"./test","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","import { AL_BITS, AL_SIZE, AL_MASK, DEBUG, BLOCK, BLOCK_OVERHEAD, BLOCK_MAXSIZE } from \"./common\";\nimport { oninit, onalloc, onresize, onmove, onfree } from \"./rtrace\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === The TLSF (Two-Level Segregate Fit) memory allocator ===\n// see: http://www.gii.upv.es/tlsf/\n\n// - `ffs(x)` is equivalent to `ctz(x)` with x != 0\n// - `fls(x)` is equivalent to `sizeof(x) * 8 - clz(x) - 1`\n\n// ╒══════════════ Block size interpretation (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┴─┴─┴─╫─┴─┴─┴─┤\n// │ | FL │ SB = SL + AL │ ◄─ usize\n// └───────────────────────────────────────────────┴───────╨───────┘\n// FL: first level, SL: second level, AL: alignment, SB: small block\n\n// @ts-ignore: decorator\n@inline const SL_BITS: u32 = 4;\n// @ts-ignore: decorator\n@inline const SL_SIZE: u32 = 1 << SL_BITS;\n\n// @ts-ignore: decorator\n@inline const SB_BITS: u32 = SL_BITS + AL_BITS;\n// @ts-ignore: decorator\n@inline const SB_SIZE: u32 = 1 << SB_BITS;\n\n// @ts-ignore: decorator\n@inline const FL_BITS: u32 = 31 - SB_BITS;\n\n// [00]: < 256B (SB) [12]: < 1M\n// [01]: < 512B [13]: < 2M\n// [02]: < 1K [14]: < 4M\n// [03]: < 2K [15]: < 8M\n// [04]: < 4K [16]: < 16M\n// [05]: < 8K [17]: < 32M\n// [06]: < 16K [18]: < 64M\n// [07]: < 32K [19]: < 128M\n// [08]: < 64K [20]: < 256M\n// [09]: < 128K [21]: < 512M\n// [10]: < 256K [22]: <= 1G - OVERHEAD\n// [11]: < 512K\n// VMs limit to 2GB total (currently), making one 1G block max (or three 512M etc.) due to block overhead\n\n// Tags stored in otherwise unused alignment bits\n\n// @ts-ignore: decorator\n@inline const FREE: usize = 1 << 0;\n// @ts-ignore: decorator\n@inline const LEFTFREE: usize = 1 << 1;\n// @ts-ignore: decorator\n@inline const TAGS_MASK: usize = FREE | LEFTFREE; // <= AL_MASK\n\n// ╒════════════════════ Block layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┼─┼─┤ ┐\n// │ size │L│F│ ◄─┐ info overhead\n// ╞>ptr═══════════════════════════════════════════════════════╧═╧═╡ │ ┘\n// │ if free: ◄ prev │ ◄─┤ usize\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: next ► │ ◄─┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ │ >= 0\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ if free: back ▲ │ ◄─┘\n// └───────────────────────────────────────────────────────────────┘ >= MIN SIZE\n// F: FREE, L: LEFTFREE\n@unmanaged export class Block extends BLOCK {\n\n /** Previous free block, if any. Only valid if free, otherwise part of payload. */\n prev: Block | null;\n /** Next free block, if any. Only valid if free, otherwise part of payload. */\n next: Block | null;\n\n // If the block is free, there is a 'back'reference at its end pointing at its start.\n}\n\n// Block constants. A block must have a minimum size of three pointers so it can hold `prev`,\n// `next` and `back` if free.\n\n// @ts-ignore: decorator\n@inline const BLOCK_MINSIZE: usize = ((3 * sizeof() + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD; // prev + next + back\n// @ts-ignore: decorator\n// @inline const BLOCK_MAXSIZE: usize = 1 << (FL_BITS + SB_BITS - 1); // exclusive, lives in common.ts\n\n/** Gets the left block of a block. Only valid if the left block is free. */\n// @ts-ignore: decorator\n@inline function GETFREELEFT(block: Block): Block {\n return load(changetype(block) - sizeof());\n}\n\n/** Gets the right block of a block by advancing to the right by its size. */\n// @ts-ignore: decorator\n@inline function GETRIGHT(block: Block): Block {\n return changetype(changetype(block) + BLOCK_OVERHEAD + (block.mmInfo & ~TAGS_MASK));\n}\n\n// ╒═════════════════════ Root layout (32-bit) ════════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ┐\n// │ 0 | flMap S│ ◄────┐\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ slMap[0] S │ ◄─┐ │\n// ├───────────────────────────────────────────────────────────────┤ │ │\n// │ slMap[1] │ ◄─┤ │\n// ├───────────────────────────────────────────────────────────────┤ u32 │\n// │ slMap[22] │ ◄─┘ │\n// ╞═══════════════════════════════════════════════════════════════╡ usize\n// │ head[0] │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ ... │ ◄────┤\n// ├───────────────────────────────────────────────────────────────┤ │\n// │ head[367] │ ◄────┤\n// ╞═══════════════════════════════════════════════════════════════╡ │\n// │ tail │ ◄────┘\n// └───────────────────────────────────────────────────────────────┘ SIZE ┘\n// S: Small blocks map\n@unmanaged class Root {\n /** First level bitmap. */\n flMap: usize;\n}\n\n// Root constants. Where stuff is stored inside of the root structure.\n\n// @ts-ignore: decorator\n@inline const SL_START: usize = sizeof();\n// @ts-ignore: decorator\n@inline const SL_END: usize = SL_START + (FL_BITS << alignof());\n// @ts-ignore: decorator\n@inline const HL_START: usize = (SL_END + AL_MASK) & ~AL_MASK;\n// @ts-ignore: decorator\n@inline const HL_END: usize = HL_START + FL_BITS * SL_SIZE * sizeof();\n// @ts-ignore: decorator\n@inline const ROOT_SIZE: usize = HL_END + sizeof();\n\n// @ts-ignore: decorator\n@lazy export let ROOT: Root = changetype(0); // unsafe initializion below\n\n/** Gets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function GETSL(root: Root, fl: usize): u32 {\n return load(\n changetype(root) + (fl << alignof()),\n SL_START\n );\n}\n\n/** Sets the second level map of the specified first level. */\n// @ts-ignore: decorator\n@inline function SETSL(root: Root, fl: usize, slMap: u32): void {\n store(\n changetype(root) + (fl << alignof()),\n slMap,\n SL_START\n );\n}\n\n/** Gets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function GETHEAD(root: Root, fl: usize, sl: u32): Block | null {\n return load(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n HL_START\n );\n}\n\n/** Sets the head of the free list for the specified combination of first and second level. */\n// @ts-ignore: decorator\n@inline function SETHEAD(root: Root, fl: usize, sl: u32, head: Block | null): void {\n store(\n changetype(root) + (((fl << SL_BITS) + sl) << alignof()),\n head,\n HL_START\n );\n}\n\n/** Gets the tail block.. */\n// @ts-ignore: decorator\n@inline function GETTAIL(root: Root): Block {\n return load(\n changetype(root),\n HL_END\n );\n}\n\n/** Sets the tail block. */\n// @ts-ignore: decorator\n@inline function SETTAIL(root: Root, tail: Block): void {\n store(\n changetype(root),\n tail,\n HL_END\n );\n}\n\n/** Inserts a previously used block back into the free list. */\nfunction insertBlock(root: Root, block: Block): void {\n if (DEBUG) assert(block); // cannot be null\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n\n // merge with right block if also free\n if (rightInfo & FREE) {\n removeBlock(root, right);\n block.mmInfo = blockInfo = blockInfo + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK); // keep block tags\n right = GETRIGHT(block);\n rightInfo = right.mmInfo;\n // 'back' is set below\n }\n\n // merge with left block if also free\n if (blockInfo & LEFTFREE) {\n let left = GETFREELEFT(block);\n let leftInfo = left.mmInfo;\n if (DEBUG) assert(leftInfo & FREE); // must be free according to right tags\n removeBlock(root, left);\n block = left;\n block.mmInfo = blockInfo = leftInfo + BLOCK_OVERHEAD + (blockInfo & ~TAGS_MASK); // keep left tags\n // 'back' is set below\n }\n\n right.mmInfo = rightInfo | LEFTFREE;\n // reference to right is no longer used now, hence rightInfo is not synced\n\n // we now know the size of the block\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be a valid size\n if (DEBUG) assert(changetype(block) + BLOCK_OVERHEAD + size == changetype(right)); // must match\n\n // set 'back' to itself at the end of block\n store(changetype(right) - sizeof(), block);\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // perform insertion\n let head = GETHEAD(root, fl, sl);\n block.prev = null;\n block.next = head;\n if (head) head.prev = block;\n SETHEAD(root, fl, sl, block);\n\n // update first and second level maps\n root.flMap |= (1 << fl);\n SETSL(root, fl, GETSL(root, fl) | (1 << sl));\n}\n\n/** Removes a free block from internal lists. */\nfunction removeBlock(root: Root, block: Block): void {\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(blockInfo & FREE); // must be free\n let size = blockInfo & ~TAGS_MASK;\n if (DEBUG) assert(size >= BLOCK_MINSIZE); // must be valid\n\n // mapping_insert\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const inv: usize = sizeof() * 8 - 1;\n let boundedSize = min(size, BLOCK_MAXSIZE);\n fl = inv - clz(boundedSize);\n sl = ((boundedSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // link previous and next free block\n let prev = block.prev;\n let next = block.next;\n if (prev) prev.next = next;\n if (next) next.prev = prev;\n\n // update head if we are removing it\n if (block == GETHEAD(root, fl, sl)) {\n SETHEAD(root, fl, sl, next);\n\n // clear second level map if head is empty now\n if (!next) {\n let slMap = GETSL(root, fl);\n SETSL(root, fl, slMap &= ~(1 << sl));\n\n // clear first level map if second level is empty now\n if (!slMap) root.flMap &= ~(1 << fl);\n }\n }\n // note: does not alter left/back because it is likely that splitting\n // is performed afterwards, invalidating those changes. so, the caller\n // must perform those updates.\n}\n\nfunction roundSize(size: usize): usize {\n const halfMaxSize = BLOCK_MAXSIZE >> 1; // don't round last fl\n const inv: usize = sizeof() * 8 - 1;\n const invRound = inv - SL_BITS;\n return size < halfMaxSize\n ? size + (1 << (invRound - clz(size))) - 1\n : size;\n}\n\n/** Searches for a free block of at least the specified size. */\nfunction searchBlock(root: Root, size: usize): Block | null {\n // size was already asserted by caller\n\n // mapping_search\n let fl: usize, sl: u32;\n if (size < SB_SIZE) {\n fl = 0;\n sl = (size >> AL_BITS);\n } else {\n const requestSize = roundSize(size);\n fl = sizeof() * 8 - 1 - clz(requestSize);\n sl = ((requestSize >> (fl - SL_BITS)) ^ (1 << SL_BITS));\n fl -= SB_BITS - 1;\n }\n if (DEBUG) assert(fl < FL_BITS && sl < SL_SIZE); // fl/sl out of range\n\n // search second level\n let slMap = GETSL(root, fl) & (~0 << sl);\n let head: Block | null = null;\n if (!slMap) {\n // search next larger first level\n let flMap = root.flMap & (~0 << (fl + 1));\n if (!flMap) {\n head = null;\n } else {\n fl = ctz(flMap);\n slMap = GETSL(root, fl);\n if (DEBUG) assert(slMap); // can't be zero if fl points here\n head = GETHEAD(root, fl, ctz(slMap));\n }\n } else {\n head = GETHEAD(root, fl, ctz(slMap));\n }\n return head;\n}\n\n/** Prepares the specified block before (re-)use, possibly splitting it. */\nfunction prepareBlock(root: Root, block: Block, size: usize): void {\n // size was already asserted by caller\n\n let blockInfo = block.mmInfo;\n if (DEBUG) assert(!((size + BLOCK_OVERHEAD) & AL_MASK)); // size must be aligned so the new block is\n\n // split if the block can hold another MINSIZE block incl. overhead\n let remaining = (blockInfo & ~TAGS_MASK) - size;\n if (remaining >= BLOCK_OVERHEAD + BLOCK_MINSIZE) {\n block.mmInfo = size | (blockInfo & LEFTFREE); // also discards FREE\n\n let spare = changetype(changetype(block) + BLOCK_OVERHEAD + size);\n spare.mmInfo = (remaining - BLOCK_OVERHEAD) | FREE; // not LEFTFREE\n insertBlock(root, spare); // also sets 'back'\n\n // otherwise tag block as no longer FREE and right as no longer LEFTFREE\n } else {\n block.mmInfo = blockInfo & ~FREE;\n GETRIGHT(block).mmInfo &= ~LEFTFREE;\n }\n}\n\n/** Adds more memory to the pool. */\nfunction addMemory(root: Root, start: usize, endU64: u64): bool {\n let end = endU64;\n if (DEBUG) assert(start <= endU64); // must be valid\n start = ((start + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n end &= ~AL_MASK;\n\n let tail = GETTAIL(root);\n let tailInfo: usize = 0;\n if (tail) { // more memory\n if (DEBUG) assert(start >= changetype(tail) + BLOCK_OVERHEAD);\n\n // merge with current tail if adjacent\n const offsetToTail = AL_SIZE;\n if (start - offsetToTail == changetype(tail)) {\n start -= offsetToTail;\n tailInfo = tail.mmInfo;\n } else {\n // We don't do this, but a user might `memory.grow` manually\n // leading to non-adjacent pages managed by TLSF.\n }\n\n } else if (DEBUG) { // first memory\n assert(start >= changetype(root) + ROOT_SIZE); // starts after root\n }\n\n // check if size is large enough for a free block and the tail block\n let size = end - start;\n if (size < BLOCK_OVERHEAD + BLOCK_MINSIZE + BLOCK_OVERHEAD) {\n return false;\n }\n\n // left size is total minus its own and the zero-length tail's header\n let leftSize = size - 2 * BLOCK_OVERHEAD;\n let left = changetype(start);\n left.mmInfo = leftSize | FREE | (tailInfo & LEFTFREE);\n left.prev = null;\n left.next = null;\n\n // tail is a zero-length used block\n tail = changetype(start + BLOCK_OVERHEAD + leftSize);\n tail.mmInfo = 0 | LEFTFREE;\n SETTAIL(root, tail);\n\n insertBlock(root, left); // also merges with free left before tail / sets 'back'\n\n return true;\n}\n\n/** Grows memory to fit at least another block of the specified size. */\nfunction growMemory(root: Root, size: usize): void {\n if (ASC_LOW_MEMORY_LIMIT) {\n unreachable();\n return;\n }\n // Here, both rounding performed in searchBlock ...\n if (size >= SB_SIZE) {\n size = roundSize(size);\n }\n // and additional BLOCK_OVERHEAD must be taken into account. If we are going\n // to merge with the tail block, that's one time, otherwise it's two times.\n let pagesBefore = memory.size();\n size += BLOCK_OVERHEAD << usize((pagesBefore << 16) - BLOCK_OVERHEAD != changetype(GETTAIL(root)));\n let pagesNeeded = (((size + 0xffff) & ~0xffff) >>> 16);\n let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n if (memory.grow(pagesWanted) < 0) {\n if (memory.grow(pagesNeeded) < 0) unreachable();\n }\n let pagesAfter = memory.size();\n addMemory(root, pagesBefore << 16, pagesAfter << 16);\n}\n\n/** Computes the size (excl. header) of a block. */\nfunction computeSize(size: usize): usize {\n // Size must be large enough and aligned minus preceeding overhead\n return size <= BLOCK_MINSIZE\n ? BLOCK_MINSIZE\n : ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n/** Prepares and checks an allocation size. */\nfunction prepareSize(size: usize): usize {\n if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n return computeSize(size);\n}\n\n/** Initializes the root structure. */\nfunction initialize(): void {\n if (isDefined(ASC_RTRACE)) oninit(__heap_base);\n let rootOffset = (__heap_base + AL_MASK) & ~AL_MASK;\n let pagesBefore = memory.size();\n let pagesNeeded = ((((rootOffset + ROOT_SIZE) + 0xffff) & ~0xffff) >>> 16);\n if (pagesNeeded > pagesBefore && memory.grow(pagesNeeded - pagesBefore) < 0) unreachable();\n let root = changetype(rootOffset);\n root.flMap = 0;\n SETTAIL(root, changetype(0));\n for (let fl: usize = 0; fl < FL_BITS; ++fl) {\n SETSL(root, fl, 0);\n for (let sl: u32 = 0; sl < SL_SIZE; ++sl) {\n SETHEAD(root, fl, sl, null);\n }\n }\n let memStart = rootOffset + ROOT_SIZE;\n if (ASC_LOW_MEMORY_LIMIT) {\n const memEnd = ASC_LOW_MEMORY_LIMIT & ~AL_MASK;\n if (memStart <= memEnd) addMemory(root, memStart, memEnd);\n else unreachable(); // low memory limit already exceeded\n } else {\n addMemory(root, memStart, memory.size() << 16);\n }\n ROOT = root;\n}\n\n/** Allocates a block of the specified size. */\nexport function allocateBlock(root: Root, size: usize): Block {\n let payloadSize = prepareSize(size);\n let block = searchBlock(root, payloadSize);\n if (!block) {\n growMemory(root, payloadSize);\n block = changetype(searchBlock(root, payloadSize));\n if (DEBUG) assert(block); // must be found now\n }\n if (DEBUG) assert((block.mmInfo & ~TAGS_MASK) >= payloadSize); // must fit\n removeBlock(root, block);\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onalloc(block);\n return block;\n}\n\n/** Reallocates a block to the specified size. */\nexport function reallocateBlock(root: Root, block: Block, size: usize): Block {\n let payloadSize = prepareSize(size);\n let blockInfo = block.mmInfo;\n let blockSize = blockInfo & ~TAGS_MASK;\n\n // possibly split and update runtime size if it still fits\n if (payloadSize <= blockSize) {\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) {\n if (payloadSize != blockSize) onresize(block, BLOCK_OVERHEAD + blockSize);\n }\n return block;\n }\n\n // merge with right free block if merger is large enough\n let right = GETRIGHT(block);\n let rightInfo = right.mmInfo;\n if (rightInfo & FREE) {\n let mergeSize = blockSize + BLOCK_OVERHEAD + (rightInfo & ~TAGS_MASK);\n if (mergeSize >= payloadSize) {\n removeBlock(root, right);\n block.mmInfo = (blockInfo & TAGS_MASK) | mergeSize;\n prepareBlock(root, block, payloadSize);\n if (isDefined(ASC_RTRACE)) onresize(block, BLOCK_OVERHEAD + blockSize);\n return block;\n }\n }\n\n // otherwise move the block\n return moveBlock(root, block, size);\n}\n\n/** Moves a block to a new one of the specified size. */\nfunction moveBlock(root: Root, block: Block, newSize: usize): Block {\n let newBlock = allocateBlock(root, newSize);\n memory.copy(changetype(newBlock) + BLOCK_OVERHEAD, changetype(block) + BLOCK_OVERHEAD, block.mmInfo & ~TAGS_MASK);\n if (changetype(block) >= __heap_base) {\n if (isDefined(ASC_RTRACE)) onmove(block, newBlock);\n freeBlock(root, block);\n }\n return newBlock;\n}\n\n/** Frees a block. */\nexport function freeBlock(root: Root, block: Block): void {\n if (isDefined(ASC_RTRACE)) onfree(block);\n block.mmInfo = block.mmInfo | FREE;\n insertBlock(root, block);\n}\n\n/** Checks that a used block is valid to be freed or reallocated. */\nfunction checkUsedBlock(ptr: usize): Block {\n let block = changetype(ptr - BLOCK_OVERHEAD);\n assert(\n ptr != 0 && !(ptr & AL_MASK) && // must exist and be aligned\n !(block.mmInfo & FREE) // must be used\n );\n return block;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __alloc(size: usize): usize {\n if (!ROOT) initialize();\n return changetype(allocateBlock(ROOT, size)) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __realloc(ptr: usize, size: usize): usize {\n if (!ROOT) initialize();\n return (ptr < __heap_base\n ? changetype(moveBlock(ROOT, checkUsedBlock(ptr), size))\n : changetype(reallocateBlock(ROOT, checkUsedBlock(ptr), size))\n ) + BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __free(ptr: usize): void {\n if (ptr < __heap_base) return;\n if (!ROOT) initialize();\n freeBlock(ROOT, checkUsedBlock(ptr));\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │ count │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │ Typeinfo#flags [id=0] │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │ ... │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n /** Flags describing the shape of this class type. */\n flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n /** No specific flags. */\n NONE = 0,\n /** Type is an `ArrayBufferView`. */\n ARRAYBUFFERVIEW = 1 << 0,\n /** Type is an `Array`. */\n ARRAY = 1 << 1,\n /** Type is a `StaticArray`. */\n STATICARRAY = 1 << 2,\n /** Type is a `Set`. */\n SET = 1 << 3,\n /** Type is a `Map`. */\n MAP = 1 << 4,\n /** Type has no outgoing pointers. */\n POINTERFREE = 1 << 5,\n /** Value alignment of 1 byte. */\n VALUE_ALIGN_0 = 1 << 6,\n /** Value alignment of 2 bytes. */\n VALUE_ALIGN_1 = 1 << 7,\n /** Value alignment of 4 bytes. */\n VALUE_ALIGN_2 = 1 << 8,\n /** Value alignment of 8 bytes. */\n VALUE_ALIGN_3 = 1 << 9,\n /** Value alignment of 16 bytes. */\n VALUE_ALIGN_4 = 1 << 10,\n /** Value is a signed type. */\n VALUE_SIGNED = 1 << 11,\n /** Value is a float type. */\n VALUE_FLOAT = 1 << 12,\n /** Value type is nullable. */\n VALUE_NULLABLE = 1 << 13,\n /** Value type is managed. */\n VALUE_MANAGED = 1 << 14,\n /** Key alignment of 1 byte. */\n KEY_ALIGN_0 = 1 << 15,\n /** Key alignment of 2 bytes. */\n KEY_ALIGN_1 = 1 << 16,\n /** Key alignment of 4 bytes. */\n KEY_ALIGN_2 = 1 << 17,\n /** Key alignment of 8 bytes. */\n KEY_ALIGN_3 = 1 << 18,\n /** Key alignment of 16 bytes. */\n KEY_ALIGN_4 = 1 << 19,\n /** Key is a signed type. */\n KEY_SIGNED = 1 << 20,\n /** Key is a float type. */\n KEY_FLOAT = 1 << 21,\n /** Key type is nullable. */\n KEY_NULLABLE = 1 << 22,\n /** Key type is managed. */\n KEY_MANAGED = 1 << 23\n}\n","import { BLOCK, BLOCK_OVERHEAD, OBJECT_OVERHEAD, OBJECT_MAXSIZE, TOTAL_OVERHEAD, DEBUG, TRACE, RTRACE, PROFILE } from \"./common\";\nimport { onvisit, oncollect, oninterrupt, onyield } from \"./rtrace\";\nimport { TypeinfoFlags } from \"../shared/typeinfo\";\nimport { E_ALLOCATION_TOO_LARGE, E_ALREADY_PINNED, E_NOT_PINNED } from \"../util/error\";\n\n// === ITCMS: An incremental Tri-Color Mark & Sweep garbage collector ===\n// Adapted from Bach Le's μgc, see: https://github.com/bullno1/ugc\n\n// ╒═════════════╤══════════════ Colors ═══════════════════════════╕\n// │ Color │ Meaning │\n// ├─────────────┼─────────────────────────────────────────────────┤\n// │ WHITE* │ Unprocessed │\n// │ BLACK* │ Processed │\n// │ GRAY │ Processed with unprocessed children │\n// │ TRANSPARENT │ Manually pinned (always reachable) │\n// └─────────────┴─────────────────────────────────────────────────┘\n// * flipped between cycles\n\n// @ts-ignore: decorator\n@lazy let white = 0;\n// @ts-ignore: decorator\n@inline const gray = 2;\n// @ts-ignore: decorator\n@inline const transparent = 3;\n// @ts-ignore: decorator\n@inline const COLOR_MASK = 3;\n\n/** Size in memory of all objects currently managed by the GC. */\n// @ts-ignore: decorator\n@lazy let total: usize = 0;\n\n/** Currently transitioning from SWEEP to MARK state. */\n// @ts-ignore: decorator\n@inline const STATE_IDLE = 0;\n/** Currently marking reachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_MARK = 1;\n/** Currently sweeping unreachable objects. */\n// @ts-ignore: decorator\n@inline const STATE_SWEEP = 2;\n/** Current collector state. */\n// @ts-ignore: decorator\n@lazy let state = STATE_IDLE;\n\n// @ts-ignore: decorator\n@lazy let fromSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let toSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let pinSpace = initLazy(changetype(memory.data(offsetof())));\n// @ts-ignore: decorator\n@lazy let iter: Object = changetype(0); // unsafe initializion below\n\nfunction initLazy(space: Object): Object {\n space.nextWithColor = changetype(space);\n space.prev = space;\n return space;\n}\n\n/** Visit cookie indicating scanning of an object. */\n// @ts-ignore: decorator\n@inline const VISIT_SCAN = 0;\n\n// ╒═══════════════ Managed object layout (32-bit) ════════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │\n// ╞═══════════════════════════════════════════════════════════╤═══╡\n// │ next │ C │ = nextWithColor\n// ├───────────────────────────────────────────────────────────┴───┤\n// │ prev │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtId │\n// ├───────────────────────────────────────────────────────────────┤\n// │ rtSize │\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n// C: color\n\n/** Represents a managed object in memory, consisting of a header followed by the object's data. */\n@unmanaged class Object extends BLOCK {\n /** Pointer to the next object with color flags stored in the alignment bits. */\n nextWithColor: usize; // *u32\n /** Pointer to the previous object. */\n prev: Object; // *u32\n /** Runtime id. */\n rtId: u32;\n /** Runtime size. */\n rtSize: u32;\n\n /** Gets the pointer to the next object. */\n get next(): Object {\n return changetype(this.nextWithColor & ~COLOR_MASK);\n }\n\n /** Sets the pointer to the next object. */\n set next(obj: Object) {\n this.nextWithColor = changetype(obj) | (this.nextWithColor & COLOR_MASK);\n }\n\n /** Gets this object's color. */\n get color(): i32 {\n return i32(this.nextWithColor & COLOR_MASK);\n }\n\n /** Sets this object's color. */\n set color(color: i32) {\n this.nextWithColor = (this.nextWithColor & ~COLOR_MASK) | color;\n }\n\n /** Gets the size of this object in memory. */\n get size(): usize {\n return BLOCK_OVERHEAD + (this.mmInfo & ~3);\n }\n\n /** Tests if this object is pointerfree. */\n get isPointerfree(): bool {\n let rtId = this.rtId;\n // 0: Object, 1: ArrayBuffer, 2: String\n return rtId <= idof() || (__typeinfo(rtId) & TypeinfoFlags.POINTERFREE) != 0;\n }\n\n /** Unlinks this object from its list. */\n unlink(): void {\n let next = this.next;\n if (next == null) {\n if (DEBUG) assert(this.prev == null && changetype(this) < __heap_base);\n return; // static data not yet linked\n }\n let prev = this.prev;\n if (DEBUG) assert(prev);\n next.prev = prev;\n prev.next = next;\n }\n\n /** Links this object to the specified list, with the given color. */\n linkTo(list: Object, withColor: i32): void {\n let prev = list.prev;\n this.nextWithColor = changetype(list) | withColor;\n this.prev = prev;\n prev.next = this;\n list.prev = this;\n }\n\n /** Marks this object as gray, that is reachable with unscanned children. */\n makeGray(): void {\n if (this == iter) iter = assert(this.prev);\n this.unlink();\n this.linkTo(toSpace, this.isPointerfree ? i32(!white) : gray);\n }\n}\n\n/** Visits all objects considered to be program roots. */\nfunction visitRoots(cookie: u32): void {\n __visit_globals(cookie);\n let pn = pinSpace;\n let iter = pn.next;\n while (iter != pn) {\n if (DEBUG) assert(iter.color == transparent);\n __visit_members(changetype(iter) + TOTAL_OVERHEAD, cookie);\n iter = iter.next;\n }\n}\n\n/** Visits all objects on the stack. */\nfunction visitStack(cookie: u32): void {\n let ptr = __stack_pointer;\n while (ptr < __heap_base) {\n __visit(load(ptr), cookie);\n ptr += sizeof();\n }\n}\n\n/** Performs a single step according to the current state. */\nfunction step(): usize {\n // Magic constants responsible for pause times. Obtained experimentally\n // using the compiler compiling itself. 2048 budget pro run by default.\n const MARKCOST = isDefined(ASC_GC_MARKCOST) ? ASC_GC_MARKCOST : 1;\n const SWEEPCOST = isDefined(ASC_GC_SWEEPCOST) ? ASC_GC_SWEEPCOST : 10;\n let obj: Object;\n switch (state) {\n case STATE_IDLE: {\n state = STATE_MARK;\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n iter = toSpace;\n return visitCount * MARKCOST;\n }\n case STATE_MARK: {\n let black = i32(!white);\n obj = iter.next;\n while (obj != toSpace) {\n iter = obj;\n if (obj.color != black) { // skip already-blacks (pointerfree)\n obj.color = black;\n visitCount = 0;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n return visitCount * MARKCOST;\n }\n obj = obj.next;\n }\n visitCount = 0;\n visitRoots(VISIT_SCAN);\n obj = iter.next;\n if (obj == toSpace) {\n visitStack(VISIT_SCAN);\n obj = iter.next;\n while (obj != toSpace) {\n if (obj.color != black) {\n obj.color = black;\n __visit_members(changetype(obj) + TOTAL_OVERHEAD, VISIT_SCAN);\n }\n obj = obj.next;\n }\n let from = fromSpace;\n fromSpace = toSpace;\n toSpace = from;\n white = black;\n iter = from.next;\n state = STATE_SWEEP;\n }\n return visitCount * MARKCOST;\n }\n case STATE_SWEEP: {\n obj = iter;\n if (obj != toSpace) {\n iter = obj.next;\n if (DEBUG) assert(obj.color == i32(!white)); // old white\n free(obj);\n return SWEEPCOST;\n }\n toSpace.nextWithColor = changetype(toSpace);\n toSpace.prev = toSpace;\n state = STATE_IDLE;\n break;\n }\n }\n return 0;\n}\n\n/** Frees an object. */\nfunction free(obj: Object): void {\n if (changetype(obj) < __heap_base) {\n obj.nextWithColor = 0; // may become linked again\n obj.prev = changetype(0);\n } else {\n total -= obj.size;\n if (isDefined(__finalize)) {\n __finalize(changetype(obj) + TOTAL_OVERHEAD);\n }\n __free(changetype(obj) + BLOCK_OVERHEAD);\n }\n}\n\n// Garbage collector interface\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __new(size: usize, id: i32): usize {\n if (size >= OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n if (total >= threshold) interrupt();\n let obj = changetype(__alloc(OBJECT_OVERHEAD + size) - BLOCK_OVERHEAD);\n obj.rtId = id;\n obj.rtSize = size;\n obj.linkTo(fromSpace, white); // inits next/prev\n total += obj.size;\n let ptr = changetype(obj) + TOTAL_OVERHEAD;\n // may be visited before being fully initialized, so must fill\n memory.fill(ptr, 0, size);\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __renew(oldPtr: usize, size: usize): usize {\n let oldObj = changetype(oldPtr - TOTAL_OVERHEAD);\n // Update object size if its block is large enough\n if (size <= (oldObj.mmInfo & ~3) - OBJECT_OVERHEAD) {\n oldObj.rtSize = size;\n return oldPtr;\n }\n // If not the same object anymore, we have to move it move it due to the\n // shadow stack potentially still referencing the old object\n let newPtr = __new(size, oldObj.rtId);\n memory.copy(newPtr, oldPtr, min(size, oldObj.rtSize));\n return newPtr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n // Write barrier is unnecessary if non-incremental\n if (!childPtr) return;\n if (DEBUG) assert(parentPtr);\n let child = changetype(childPtr - TOTAL_OVERHEAD);\n if (child.color == white) {\n let parent = changetype(parentPtr - TOTAL_OVERHEAD);\n let parentColor = parent.color;\n if (parentColor == i32(!white)) {\n // Maintain the invariant that no black object may point to a white object.\n if (expectMultiple) {\n // Move the barrier \"backward\". Suitable for containers receiving multiple stores.\n // Avoids a barrier for subsequent objects stored into the same container.\n parent.makeGray();\n } else {\n // Move the barrier \"forward\". Suitable for objects receiving isolated stores.\n child.makeGray();\n }\n } else if (parentColor == transparent && state == STATE_MARK) {\n // Pinned objects are considered 'black' during the mark phase.\n child.makeGray();\n }\n }\n}\n\n// @ts-ignore: decorator\n@lazy let visitCount = 0;\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __visit(ptr: usize, cookie: i32): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (RTRACE) if (!onvisit(obj)) return;\n if (obj.color == white) {\n obj.makeGray();\n ++visitCount;\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n if (ptr) {\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color == transparent) {\n throw new Error(E_ALREADY_PINNED);\n }\n obj.unlink(); // from fromSpace\n obj.linkTo(pinSpace, transparent);\n }\n return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n if (!ptr) return;\n let obj = changetype(ptr - TOTAL_OVERHEAD);\n if (obj.color != transparent) {\n throw new Error(E_NOT_PINNED);\n }\n if (state == STATE_MARK) {\n // We may be right at the point after marking roots for the second time and\n // entering the sweep phase, in which case the object would be missed if it\n // is not only pinned but also a root. Make sure it isn't missed.\n obj.makeGray();\n } else {\n obj.unlink();\n obj.linkTo(fromSpace, white);\n }\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n if (TRACE) trace(\"GC (full) at\", 1, total);\n if (state > STATE_IDLE) {\n // finish current cycle\n while (state != STATE_IDLE) step();\n }\n // perform a full cycle\n step();\n while (state != STATE_IDLE) step();\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (TRACE) trace(\"GC (full) done at cur/max\", 2, total, memory.size() << 16);\n if (RTRACE || PROFILE) oncollect(total);\n}\n\n// Garbage collector automation\n\n/** How often to interrupt. The default of 1024 means \"interrupt each 1024 bytes allocated\". */\n// @ts-ignore: decorator\n@inline const GRANULARITY: usize = isDefined(ASC_GC_GRANULARITY) ? ASC_GC_GRANULARITY : 1024;\n/** How long to interrupt. The default of 200% means \"run at double the speed of allocations\". */\n// @ts-ignore: decorator\n@inline const STEPFACTOR: usize = isDefined(ASC_GC_SWEEPFACTOR) ? ASC_GC_SWEEPFACTOR : 200;\n/** How long to idle. The default of 200% means \"wait for memory to double before kicking in again\". */\n// @ts-ignore: decorator\n@inline const IDLEFACTOR: usize = isDefined(ASC_GC_IDLEFACTOR) ? ASC_GC_IDLEFACTOR : 200;\n\n/** Threshold of memory used by objects to exceed before interrupting again. */\n// @ts-ignore: decorator\n@lazy let threshold: usize = ((memory.size() << 16) - __heap_base) >> 1;\n\n/** Performs a reasonable amount of incremental GC steps. */\nfunction interrupt(): void {\n if (PROFILE) oninterrupt(total);\n if (TRACE) trace(\"GC (auto) at\", 1, total);\n let budget: isize = GRANULARITY * STEPFACTOR / 100;\n do {\n budget -= step();\n if (state == STATE_IDLE) {\n if (TRACE) trace(\"└ GC (auto) done at cur/max\", 2, total, memory.size() << 16);\n threshold = (total * IDLEFACTOR / 100) + GRANULARITY;\n if (PROFILE) onyield(total);\n return;\n }\n } while (budget > 0);\n if (TRACE) trace(\"└ GC (auto) ongoing at\", 1, total);\n threshold = total + GRANULARITY * usize(total - threshold < GRANULARITY);\n if (PROFILE) onyield(total);\n}\n","export enum Arguments {\n Zero = 0,\n OneImm = 1,\n TwoImm = 2,\n OneOff = 3,\n OneRegOneImm = 4,\n OneRegOneExtImm = 5,\n OneRegTwoImm = 6,\n OneRegOneImmOneOff = 7,\n TwoReg = 8,\n TwoRegOneImm = 9,\n TwoRegOneOff = 10,\n TwoRegTwoImm = 11,\n ThreeReg = 12,\n}\n\n/** How many numbers in `Args` is relevant for given `Arguments`. */\nexport const RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];\n/** How many bytes is required by given `Arguments`. */\nexport const REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];\n\n// @unmanaged\nexport class Args {\n static from(a: u32, b: u32 = 0, c: u32 = 0, d: u32 = 0): Args {\n const x = new Args();\n x.a = a;\n x.b = b;\n x.c = c;\n x.d = d;\n return x;\n }\n\n /**\n * TwoReg: `omega_A`\n * TwoRegOneOff: `omega_B`\n * ThreeReg: `omega_B`\n */\n a: u32 = 0;\n /**\n * TwoReg: `omega'_D`\n * TwoRegOneOff: `omega'_A`\n * ThreeReg: `omega_A`\n */\n b: u32 = 0;\n /**\n * ThreeReg: `omega'_D`\n */\n c: u32 = 0;\n d: u32 = 0;\n}\n\ntype ArgsDecoder = (data: Uint8Array, immLimit: u32) => Args;\n\nfunction twoImm(data: Uint8Array, lim: u32): Args {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.low) + 1;\n const first = decodeI32(data, 1, split);\n const second = decodeI32(data, split, lim);\n return Args.from(first, second, 0, 0);\n}\n\nexport const DECODERS: ArgsDecoder[] = [\n // DECODERS[Arguments.Zero] =\n (_d, _l) => {\n return Args.from(0, 0, 0, 0);\n },\n // DECODERS[Arguments.OneImm] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.TwoImm] =\n (data, lim) => twoImm(data, lim),\n // DECODERS[Arguments.OneOff] =\n (data, lim) => {\n return Args.from(decodeI32(data, 0, lim), 0, 0, 0);\n },\n // DECODERS[Arguments.OneRegOneImm] =\n (data, lim) => {\n return Args.from(nibbles(data[0]).low, decodeI32(data, 1, lim), 0, 0);\n },\n // DECODERS[Arguments.OneRegOneExtImm] =\n (data, _lim) => {\n const a = nibbles(data[0]).low;\n const b = decodeU32(data.subarray(1));\n const c = decodeU32(data.subarray(5));\n return Args.from(a, b, c, 0);\n },\n //DECODERS[Arguments.OneRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const immB = decodeI32(data, split, lim);\n return Args.from(n.low, immA, immB, 0);\n },\n // DECODERS[Arguments.OneRegOneImmOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const split = Math.min(4, n.hig) + 1;\n const immA = decodeI32(data, 1, split);\n const offs = decodeI32(data, split, lim);\n return Args.from(n.low, immA, offs, 0);\n },\n // DECODERS[Arguments.TwoReg] =\n (data, _lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, 0, 0);\n },\n // DECODERS[Arguments.TwoRegOneImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegOneOff] =\n (data, lim) => {\n const n = nibbles(data[0]);\n return Args.from(n.hig, n.low, decodeI32(data, 1, lim), 0);\n },\n // DECODERS[Arguments.TwoRegTwoImm] =\n (data, lim) => {\n const n = nibbles(data[0]);\n const result = twoImm(data.subarray(1), lim > 1 ? lim - 1 : 0);\n return Args.from(n.hig, n.low, result.a, result.b);\n },\n // DECODERS[Arguments.ThreeReg] =\n (data, _lim) => {\n const a = nibbles(data[0]);\n const b = nibbles(data[1]);\n return Args.from(a.hig, a.low, b.low, 0);\n },\n];\n\n// @unmanaged\nclass Nibbles {\n low: u8 = 0;\n hig: u8 = 0;\n}\n\n// @inline\nexport function nibbles(byte: u8): Nibbles {\n const low = byte & 0xf;\n const hig = byte >> 4;\n const n = new Nibbles();\n n.low = low;\n n.hig = hig;\n return n;\n}\n\n//@inline\nfunction decodeI32(input: Uint8Array, start: u32, end: u32): u32 {\n const data = input.subarray(start, end > start ? end : start);\n const len = Math.min(4, data.length);\n let num = 0;\n for (let i: u32 = 0; i < len; i++) {\n num |= u32(data[i]) << (i * 8);\n }\n\n const msb = len > 0 ? data[len - 1] & 0x80 : 0;\n const prefix = msb > 0 ? 0xff : 0x00;\n for (let i: u32 = len; i < 4; i++) {\n num |= prefix << (i * 8);\n }\n return num;\n}\n\nexport function encodeI32(input: i32): u8[] {\n const data: u8[] = [];\n let num = u32(input);\n while (num > 0) {\n data.push(u8(num));\n num >>= 8;\n }\n return data;\n}\n\nfunction decodeU32(data: Uint8Array): u32 {\n let num = u32(data[0]);\n num |= u32(data[1]) << 8;\n num |= u32(data[2]) << 16;\n num |= u32(data[3]) << 24;\n return num;\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n /** Simple bump allocator without GC. */\n Stub = 0,\n /** Stop the world semi-automatic GC. */\n Minimal = 1,\n /** incremental GC. */\n Incremental = 2,\n}\n","/// \n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1,\n 10,\n 100,\n 1000,\n 10000,\n 100000,\n 1000000,\n 10000000,\n 100000000,\n 1000000000\n]);\n\n/*\n Lookup table for pairwise char codes in range [0-99]\n\n \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data([\n 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n 0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n 0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n 0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n 0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n 0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n 0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n 0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n 0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n 0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n 0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n 0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n 0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n 0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n 0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n 0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n 0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n 0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data([/* eslint-disable indent */\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,\n -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,\n -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,\n -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,\n -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,\n 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,\n 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,\n 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,\n 907, 933, 960, 986, 1013, 1039, 1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data([\n 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n 0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n 0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n 0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n 0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n 0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n 0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n 0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n 0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n 0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n 0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n 0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n 0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n 0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n 0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n 0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n 0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n 0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n 0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n 0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2(value: T): bool {\n return popcnt(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n if (value < 100000) {\n if (value < 100) {\n return 1 + u32(value >= 10);\n } else {\n return 3 + u32(value >= 10000) + u32(value >= 1000);\n }\n } else {\n if (value < 10000000) {\n return 6 + u32(value >= 1000000);\n } else {\n return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n }\n }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n if (value < 1000000000000000) {\n if (value < 1000000000000) {\n return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n } else {\n return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n }\n } else {\n if (value < 100000000000000000) {\n return 16 + u32(value >= 10000000000000000);\n } else {\n return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n }\n }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n if (isPowerOf2(base)) {\n return (63 - clz(num)) / (31 - clz(base)) + 1;\n }\n let b64 = u64(base), b = b64, e: u32 = 1;\n while (num >= b) {\n num /= b;\n b *= b;\n e <<= 1;\n }\n while (num >= 1) {\n num /= b64;\n e++;\n }\n return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n while (num >= 10000) {\n // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n let t = num / 10000;\n let r = num % 10000;\n num = t;\n\n let d1 = r / 100;\n let d2 = r % 100;\n\n let digits1 = load(DIGITS + (d1 << alignof()));\n let digits2 = load(DIGITS + (d2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n if (num >= 100) {\n let t = num / 100;\n let d1 = num % 100;\n num = t;\n offset -= 2;\n let digits = load(DIGITS + (d1 << alignof()));\n store(buffer + (offset << 1), digits);\n }\n\n if (num >= 10) {\n offset -= 2;\n let digits = load(DIGITS + (num << alignof()));\n store(buffer + (offset << 1), digits);\n } else {\n offset -= 1;\n let digit = CharCode._0 + num;\n store(buffer + (offset << 1), digit);\n }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n while (num >= 100000000) {\n let t = num / 100000000;\n let r = (num - t * 100000000);\n num = t;\n\n let b = r / 10000;\n let c = r % 10000;\n\n let b1 = b / 100;\n let b2 = b % 100;\n let c1 = c / 100;\n let c2 = c % 100;\n\n let digits1 = load(DIGITS + (c1 << alignof()));\n let digits2 = load(DIGITS + (c2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n digits1 = load(DIGITS + (b1 << alignof()));\n digits2 = load(DIGITS + (b2 << alignof()));\n\n offset -= 4;\n store(buffer + (offset << 1), digits1 | (digits2 << 32));\n }\n\n utoa32_dec_lut(buffer, num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n const lut = changetype(HEX_DIGITS);\n while (offset >= 2) {\n offset -= 2;\n store(\n buffer + (offset << 1),\n load(lut + ((num & 0xFF) << alignof()))\n );\n num >>= 8;\n }\n if (offset & 1) {\n store(buffer, load(lut + (num << 6)));\n }\n}\n\nfunction utoa_dec_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let t = num / 10;\n let r = (num % 10);\n num = changetype(t);\n offset--;\n store(buffer + (offset << 1), CharCode._0 + r);\n } while (num);\n}\n\nfunction utoa_hex_simple(buffer: usize, num: T, offset: usize): void {\n do {\n let d = num & 0x0F | CharCode._0;\n d += select(0x27, 0, d > CharCode._9);\n offset--;\n store(buffer + (offset << 1), d);\n // @ts-ignore: type\n num >>= 4;\n } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa32_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_dec_simple(buffer, num, offset);\n } else {\n utoa64_dec_lut(buffer, num, offset);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n utoa_hex_simple(buffer, num, offset);\n } else {\n utoa_hex_lut(buffer, num, offset);\n }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n const lut = changetype(ANY_DIGITS);\n let base = u64(radix);\n if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n let shift = u64(ctz(radix) & 7);\n let mask = base - 1;\n do {\n offset--;\n store(buffer + (offset << 1), load(lut + (usize(num & mask) << 1)));\n num >>= shift;\n } while (num);\n } else {\n do {\n offset--;\n let q = num / base;\n store(buffer + (offset << 1), load(lut + (usize(num - q * base) << 1)));\n num = q;\n } while (num);\n }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa32_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = (value >>> 31) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n let decimals = decimalCount32(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, value, decimals);\n } else if (radix == 16) {\n let decimals = (31 - clz(value) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let val32 = u32(value);\n let decimals = ulog_base(val32, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, val32, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new(decimals << 1, idof()));\n utoa32_dec_core(changetype(out), val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_dec_core(changetype(out), value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new(decimals << 1, idof()));\n utoa64_hex_core(changetype(out), value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new(decimals << 1, idof()));\n utoa64_any_core(changetype(out), value, decimals, radix);\n }\n return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n if (radix < 2 || radix > 36) {\n throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n }\n if (!value) return \"0\";\n\n let sign = u32(value >>> 63) << 1;\n if (sign) value = -value;\n let out: String;\n\n if (radix == 10) {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n let decimals = decimalCount32(val32);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa32_dec_core(changetype(out) + sign, val32, decimals);\n } else {\n let decimals = decimalCount64High(value);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_dec_core(changetype(out) + sign, value, decimals);\n }\n } else if (radix == 16) {\n let decimals = (63 - u32(clz(value)) >> 2) + 1;\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_hex_core(changetype(out) + sign, value, decimals);\n } else {\n let decimals = ulog_base(value, radix);\n out = changetype(__new((decimals << 1) + sign, idof()));\n utoa64_any_core(changetype(out) + sign, value, decimals, radix);\n }\n if (sign) store(changetype(out), CharCode.MINUS);\n return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n let u0 = u & 0xFFFFFFFF;\n let v0 = v & 0xFFFFFFFF;\n\n let u1 = u >> 32;\n let v1 = v >> 32;\n\n let l = u0 * v0;\n let t = u1 * v0 + (l >> 32);\n let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n w += 0x7FFFFFFF; // rounding\n\n t >>= 32;\n w >>= 32;\n\n return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n let frc = (f << 1) + 1;\n let exp = e - 1;\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n _frc_plus = frc;\n _frc_minus = ((f << m) - 1) << e - m - exp;\n _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n let lastp = buffer + ((len - 1) << 1);\n let digit = load(lastp);\n while (\n rest < wp_w &&\n delta - rest >= ten_kappa && (\n rest + ten_kappa < wp_w ||\n wp_w - rest > rest + ten_kappa - wp_w\n )\n ) {\n --digit;\n rest += ten_kappa;\n }\n store(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n const c = reinterpret(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n let dk = (-61 - minExp) * c + 347;\t // dk must be positive, so can do ceiling in positive\n let k = dk;\n k += i32(k != dk); // conversion with ceil\n\n let index = (k >> 3) + 1;\n _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n _frc_pow = load(FRC_POWERS + (index << alignof()));\n _exp_pow = load(EXP_POWERS + (index << alignof()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n let frc: u64;\n let exp: i32;\n\n // frexp routine\n if (isSingle) {\n let uv = reinterpret(value);\n exp = (uv & 0x7F800000) >>> 23;\n let sid = uv & 0x007FFFFF;\n frc = (u64(exp != 0) << 23) + sid;\n exp = (exp || 1) - (0x7F + 23);\n } else {\n let uv = reinterpret(value);\n exp = i32((uv & 0x7FF0000000000000) >>> 52);\n let sid = uv & 0x000FFFFFFFFFFFFF;\n frc = (u64(exp != 0) << 52) + sid;\n exp = (exp || 1) - (0x3FF + 52);\n }\n\n normalizedBoundaries(frc, exp, isSingle);\n getCachedPower(_exp);\n\n // normalize\n let off = clz(frc);\n frc <<= off;\n exp -= off;\n\n let frc_pow = _frc_pow;\n let exp_pow = _exp_pow;\n\n let w_frc = umul64f(frc, frc_pow);\n let w_exp = umul64e(exp, exp_pow);\n\n let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n let wp_exp = umul64e(_exp, exp_pow);\n\n let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n let delta = wp_frc - wm_frc;\n\n return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n let one_exp = -mp_exp;\n let one_frc = (1) << one_exp;\n let mask = one_frc - 1;\n\n let wp_w_frc = mp_frc - w_frc;\n\n let p1 = u32(mp_frc >> one_exp);\n let p2 = mp_frc & mask;\n\n let kappa = decimalCount32(p1);\n let len = sign;\n\n while (kappa > 0) {\n let d: u32;\n switch (kappa) {\n case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n case 9: { d = p1 / 100000000; p1 %= 100000000; break; }\n case 8: { d = p1 / 10000000; p1 %= 10000000; break; }\n case 7: { d = p1 / 1000000; p1 %= 1000000; break; }\n case 6: { d = p1 / 100000; p1 %= 100000; break; }\n case 5: { d = p1 / 10000; p1 %= 10000; break; }\n case 4: { d = p1 / 1000; p1 %= 1000; break; }\n case 3: { d = p1 / 100; p1 %= 100; break; }\n case 2: { d = p1 / 10; p1 %= 10; break; }\n case 1: { d = p1; p1 = 0; break; }\n default: { d = 0; break; }\n }\n\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n --kappa;\n let tmp = ((p1) << one_exp) + p2;\n if (tmp <= delta) {\n _K += kappa;\n grisuRound(buffer, len, delta, tmp, load(POWERS10 + (kappa << alignof())) << one_exp, wp_w_frc);\n return len;\n }\n }\n\n while (true) {\n p2 *= 10;\n delta *= 10;\n\n let d = p2 >> one_exp;\n if (d | len) store(buffer + (len++ << 1), CharCode._0 + d);\n\n p2 &= mask;\n --kappa;\n if (p2 < delta) {\n _K += kappa;\n wp_w_frc *= load(POWERS10 + (-kappa << alignof()));\n grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n return len;\n }\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n let sign = k < 0;\n if (sign) k = -k;\n let decimals = decimalCount32(k) + 1;\n utoa32_dec_core(buffer, k, decimals);\n store(buffer, select(CharCode.MINUS, CharCode.PLUS, sign));\n return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n if (!k) {\n store(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n return length + 2;\n }\n\n let kk = length + k;\n if (length <= kk && kk <= 21) {\n // 1234e7 -> 12340000000\n for (let i = length; i < kk; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n store(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n return kk + 2;\n } else if (kk > 0 && kk <= 21) {\n // 1234e-2 -> 12.34\n let ptr = buffer + (kk << 1);\n memory.copy(\n ptr + 2,\n ptr,\n -k << 1\n );\n store(buffer + (kk << 1), CharCode.DOT);\n return length + 1;\n } else if (-6 < kk && kk <= 0) {\n // 1234e-6 -> 0.001234\n let offset = 2 - kk;\n memory.copy(\n buffer + (offset << 1),\n buffer,\n length << 1\n );\n store(buffer, CharCode._0 | (CharCode.DOT << 16));\n for (let i = 2; i < offset; ++i) {\n store(buffer + (i << 1), CharCode._0);\n }\n return length + offset;\n } else if (length == 1) {\n // 1e30\n store(buffer, CharCode.e, 2);\n length = genExponent(buffer + 4, kk - 1);\n return length + 2;\n } else {\n let len = length << 1;\n memory.copy(\n buffer + 4,\n buffer + 2,\n len - 2\n );\n store(buffer, CharCode.DOT, 2);\n store(buffer + len, CharCode.e, 2);\n length += genExponent(buffer + len + 4, kk - 1);\n return length + 2;\n }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n let sign = i32(value < 0);\n if (sign) {\n value = -value;\n store(buffer, CharCode.MINUS);\n }\n // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n let len = grisu2(value, buffer, sign, isSingle);\n len = prettify(buffer + (sign << 1), len - sign, _K);\n return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa(value: T): String {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n if (value == 0) return \"0.0\";\n if (!isFinite(value)) {\n if (isNaN(value)) return \"NaN\";\n return select(\"-Infinity\", \"Infinity\", value < 0);\n }\n let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n let result = changetype(__new(size, idof()));\n memory.copy(changetype(result), dtoa_buf, size);\n return result;\n}\n\nexport function itoa_buffered(buffer: usize, value: T): u32 {\n let sign: u32 = 0;\n if (isSigned()) {\n sign = u32(value < 0);\n if (sign) {\n if (sizeof() == 1) {\n if (value == -0x80) {\n // -0x80 -> -128\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 1) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 8) << 48\n );\n return 4;\n }\n }\n if (sizeof() == 2) {\n if (value == -0x8000) {\n // -0x8000 -> -32768\n store(buffer,\n CharCode.MINUS |\n (CharCode._0 + 3) << 16 |\n (CharCode._0 + 2) << 32 |\n (CharCode._0 + 7) << 48\n ); // -327\n store(buffer + 8,\n (CharCode._0 + 6) << 0 |\n (CharCode._0 + 8) << 16\n ); // 68\n return 6;\n }\n }\n store(buffer, CharCode.MINUS);\n // @ts-ignore\n value = -value;\n }\n }\n let dest = buffer + (sign << 1);\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isSigned()) {\n if (sizeof() <= 4) {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n } else {\n if (value < 10) {\n store(dest, value | CharCode._0);\n return 1 + sign;\n }\n }\n } else {\n if (value < 10) {\n store(buffer, value | CharCode._0);\n return 1;\n }\n }\n }\n let decimals: u32 = 0;\n if (sizeof() <= 4) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n if (value <= u32.MAX_VALUE) {\n let val32 = value;\n decimals = decimalCount32(val32);\n utoa32_dec_core(dest, val32, decimals);\n } else {\n let val64 = value;\n decimals = decimalCount64High(val64);\n utoa64_dec_core(dest, val64, decimals);\n }\n }\n return sign + decimals;\n}\n\nexport function dtoa_buffered(buffer: usize, value: T): u32 {\n const isSingle = isFloat() && sizeof() == 4;\n return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n if (value == 0) {\n store(buffer, CharCode._0);\n store(buffer, CharCode.DOT, 2);\n store(buffer, CharCode._0, 4);\n return 3;\n }\n if (!isFinite(value)) {\n if (isNaN(value)) {\n store(buffer, CharCode.N);\n store(buffer, CharCode.a, 2);\n store(buffer, CharCode.N, 4);\n return 3;\n } else {\n let sign = value < 0;\n if (sign) {\n store(buffer, CharCode.MINUS); // -\n buffer += 2;\n }\n store(buffer, 0x690066006E0049, 0); // ifnI\n store(buffer, 0x7900740069006E, 8); // ytin\n return 8 + u32(sign);\n }\n }\n return dtoa_core(buffer, value, isSingle);\n}\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data([\n // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n // used for computing 2^(k/N) for an int |k| < 150 N as\n // double(tab[k%N] + (k << 52-BITS))\n 0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n 0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n 0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n 0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n 0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n 0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n 0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n 0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N, // 0x1.8p+52\n Ox127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x430) {\n // |x| >= 128 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > 0) return x * Ox127f; // x > 0 -> HugeVal (Owerflow)\n if (x <= -150) return 0; // x <= -150 -> 0 (Underflow)\n }\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n let kd = xd + shift;\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n y = C2 * r + 1;\n y += (C0 * r + C1) * (r * r);\n y *= s;\n\n return y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000), // 0x1.8p+52\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep+0\n Ox1p127f = reinterpret(0x7F000000);\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3) / N / N, // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6) / N; // 0x1.62e42ff0c52d6p-1\n\n let xd = x;\n let ix = reinterpret(x);\n let ux = ix >> 20 & 0x7FF;\n if (ux >= 0x42B) {\n // |x| >= 88 or x is nan.\n if (ix == 0xFF800000) return 0; // x == -Inf -> 0\n if (ux >= 0x7F8) return x + x; // x == Inf/NaN -> Inf/NaN\n if (x > reinterpret(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128) ~= 88.72 -> HugeVal (Owerflow)\n if (x < reinterpret(0xC2CFF1B4)) return 0; // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n }\n\n // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n let z = InvLn2N * xd;\n\n // Round and convert z to int, the result is in [-150*N, 128*N] and\n // ideally ties-to-even rule is used, otherwise the magnitude of r\n // can be bigger which gives larger approximation error.\n let kd = (z + shift);\n let ki = reinterpret(kd);\n let r = z - (kd - shift);\n let s: f64, y: f64, t: u64;\n\n // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += ki << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n\n return y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n 0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n 0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n 0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n 0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n 0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n 0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n 0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0x0,\n 0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1, 0x1.338ca9f24f53dp-4,\n 0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 , 0x1.476a9543891bap-3,\n 0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1, 0x1.e840b4ac4e4d2p-3,\n 0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1, 0x1.40645f0c6651cp-2,\n 0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1, 0x1.88e9c2c1b9ff8p-2,\n 0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC // 0x1.767dcf5534862p-1, 0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOG2F_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n A0 = reinterpret(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n A1 = reinterpret(0x3FDECABF496832E0), // 0x1.ecabf496832ep-2\n A2 = reinterpret(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n A3 = reinterpret(0x3FF715475F35C8B8); // 0x1.715475f35c8b8p0\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if (ux * 2 == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log2(inf) == inf.\n if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n let top = tmp & 0xFF800000;\n let iz = ux - top;\n let k = tmp >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(iz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A1 * r + A2;\n let p = A3 * r + y0;\n let r2 = r * r;\n y += A0 * r2;\n y = y * r2 + p;\n\n return y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data([\n 0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n 0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n 0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n 0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n 0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n 0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3 ,\n 0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n 0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n 0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n 0x3FF0000000000000, 0, // 0x1p+0, 0,\n 0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1, 0x1.aa5aa5df25984p-5,\n 0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 , 0x1.c5e53aa362eb4p-4,\n 0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1, 0x1.526e57720db08p-3,\n 0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1, 0x1.bc2860d22477p-3 ,\n 0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1, 0x1.1058bc8a07ee1p-2,\n 0x3FE767DCF5534862, 0x3FD4043057B6EE09 // 0x1.767dcf5534862p-1, 0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n const\n N_MASK = (1 << LOGF_TABLE_BITS) - 1,\n Ox1p23f = reinterpret(0x4B000000); // 0x1p23f\n\n const\n Ln2 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n A0 = reinterpret(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n A1 = reinterpret(0x3FD5575B0BE00B6A), // 0x1.5575b0be00b6ap-2\n A2 = reinterpret(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n let ux = reinterpret(x);\n // Fix sign of zero with downward rounding when x==1.\n // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n // x < 0x1p-126 or inf or nan.\n if ((ux << 1) == 0) return -Infinity;\n if (ux == 0x7F800000) return x; // log(inf) == inf.\n if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ux = reinterpret(x * Ox1p23f);\n ux -= 23 << 23;\n }\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n let k = tmp >> 23;\n let iz = ux - (tmp & 0x1FF << 23);\n\n let invc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOGF_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n let r = z * invc - 1;\n let y0 = logc + k * Ln2;\n\n // Pipelined polynomial evaluation to approximate log1p(r).\n let r2 = r * r;\n let y = A1 * r + A2;\n y += A0 * r2;\n y = y * r2 + (y0 + r);\n\n return y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n return (ux << 1) - 1 >= (0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n let e = iy >> 23 & 0xFF;\n if (e < 0x7F ) return 0;\n if (e > 0x7F + 23) return 2;\n e = 1 << (0x7F + 23 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n const\n A0 = reinterpret(0x3FD27616C9496E0B), // 0x1.27616c9496e0bp-2\n A1 = reinterpret(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n A2 = reinterpret(0x3FDEC70A6CA7BADD), // 0x1.ec70a6ca7baddp-2\n A3 = reinterpret(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n A4 = reinterpret(0x3FF71547652AB82B); // 0x1.71547652ab82bp+0\n\n // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ux - 0x3F330000;\n let i = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n let top = tmp & 0xFF800000;\n let uz = ux - top;\n let k = top >> 23;\n\n let invc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 0 << alignof());\n let logc = load(LOG2F_DATA_TAB + (i << (1 + alignof())), 1 << alignof());\n let z = reinterpret(uz);\n\n // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n let r = z * invc - 1;\n let y0 = logc + k;\n\n // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n let y = A0 * r + A1;\n let p = A2 * r + A3;\n let q = A4 * r + y0;\n\n r *= r;\n q += p * r;\n y = y * (r * r) + q;\n\n return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not. The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n const\n N = 1 << EXP2F_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p+52\n\n const\n C0 = reinterpret(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n C1 = reinterpret(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n C2 = reinterpret(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n // x = k/N + r with r in [-1/(2N), 1/(2N)]\n let kd = (xd + shift);\n let ki = reinterpret(kd);\n let r = xd - (kd - shift);\n let t: u64, z: f64, y: f64, s: f64;\n\n // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n t = load(EXP2F_DATA_TAB + ((ki & N_MASK) << alignof()));\n t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n s = reinterpret(t);\n z = C0 * r + C1;\n y = C2 * r + 1;\n y += z * (r * r);\n y *= s;\n return y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n return xflowf(sign, reinterpret(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n const\n Ox1p23f = reinterpret(0x4B000000), // 0x1p23f\n UPPER_LIMIT = reinterpret(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n LOWER_LIMIT = -150.0,\n SIGN_BIAS = 1 << (EXP2F_TABLE_BITS + 11);\n\n let signBias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let ny = 0;\n\n if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n if (ny) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3F800000) return NaN; // original: 1.0\n if ((ix << 1) > (0x7F800000 << 1) || (iy << 1) > (0x7F800000 << 1)) return x + y;\n if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n return y * y;\n }\n if (zeroinfnanf(ix)) {\n let x2 = x * x;\n if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // x and y are non-zero finite.\n if (ix < 0) {\n // Finite x < 0.\n let yint = checkintf(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) signBias = SIGN_BIAS;\n ix &= 0x7FFFFFFF;\n }\n if (ix < 0x00800000) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p23f);\n ix &= 0x7FFFFFFF;\n ix -= 23 << 23;\n }\n }\n let logx = log2f_inline(ix);\n let ylogx = y * logx; // cannot overflow, y is single prec.\n if ((reinterpret(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret(126.0) >> 47\n // |y * log(x)| >= 126\n if (ylogx > UPPER_LIMIT) return oflowf(signBias); // overflow\n if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n }\n return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data([\n 0x0000000000000000, 0x3FF0000000000000,\n 0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n 0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n 0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n 0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n 0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n 0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n 0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n 0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n 0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n 0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n 0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n 0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n 0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n 0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n 0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n 0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n 0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n 0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n 0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n 0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n 0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n 0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n 0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n 0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n 0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n 0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n 0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n 0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n 0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n 0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n 0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n 0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n 0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n 0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n 0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n 0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n 0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n 0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n 0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n 0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n 0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n 0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n 0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n 0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n 0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n 0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n 0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n 0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n 0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n 0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n 0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n 0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n 0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n 0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n 0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n 0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n 0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n 0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n 0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n 0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n 0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n 0xBC93CEDD78565858, 0x3FEEA23882552225,\n 0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n 0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n 0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n 0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n 0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n 0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n 0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n 0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n 0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n 0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n 0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n 0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n 0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n 0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n 0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n 0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n 0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n 0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n 0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n 0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n 0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n 0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n 0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n 0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n 0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n 0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n 0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n 0xBC87C50422622263, 0x3FEECC667B5DE565,\n 0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n 0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n 0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n 0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n 0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n 0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n 0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n 0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n 0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n 0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n 0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n 0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n 0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n 0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n 0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n 0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n 0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n 0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n 0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n 0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n 0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n 0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n 0xBC82919E2040220F, 0x3FEF60E316C98398,\n 0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n 0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n 0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n 0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n 0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n 0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n 0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n 0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n 0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n 0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n 0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n 0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n 0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n 0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n const\n Ox1p_1022 = reinterpret(0x0010000000000000), // 0x1p-1022\n Ox1p1009 = reinterpret(0x7F00000000000000); // 0x1p1009\n\n let scale: f64;\n if (!(ki & 0x80000000)) {\n // k > 0, the exponent of scale might have overflowed by <= 460.\n sbits -= u64(1009) << 52;\n scale = reinterpret(sbits);\n return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n }\n // k < 0, need special care in the subnormal range.\n sbits += u64(1022) << 52;\n // Note: sbits is signed scale.\n scale = reinterpret(sbits);\n let y = scale + scale * tmp;\n if (abs(y) < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let one = copysign(1.0, y);\n let lo = scale - y + scale * tmp;\n let hi = one + y;\n lo = one - hi + y + lo;\n y = (hi + lo) - one;\n // Fix the sign of 0.\n if (y == 0.0) y = reinterpret(sbits & 0x8000000000000000);\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52;\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) {\n return 1.0 + x;\n } else {\n return select(0, Infinity, ux < 0);\n }\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n let z = InvLn2N * x;\n // #if TOINT_INTRINSICS\n // \tkd = roundtoint(z);\n // \tki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // let kd = z + shift;\n // let ki = reinterpret(kd) >> 16;\n // let kd = ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes.\n let kd = z + shift;\n let ki = reinterpret(kd);\n kd -= shift;\n // #endif\n let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // 2^(k/N) ~= scale * (1 + tail).\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()))); // T[idx]\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n let r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double. (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n const Ox1p_1022 = reinterpret(0x10000000000000); // 0x1p-1022\n let scale: f64;\n if ((ki & 0x80000000) == 0) {\n // k > 0, the exponent of scale might have overflowed by 1\n sbits -= u64(1) << 52;\n scale = reinterpret(sbits);\n return 2 * (scale * tmp + scale);\n }\n // k < 0, need special care in the subnormal range\n sbits += u64(1022) << 52;\n scale = reinterpret(sbits);\n let y = scale * tmp + scale;\n if (y < 1.0) {\n // Round y to the right precision before scaling it into the subnormal\n // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n // E is the worst-case ulp error outside the subnormal range. So this\n // is only useful if the goal is better than 1 ulp worst-case error.\n let hi: f64, lo: f64;\n lo = scale - y + scale * tmp;\n hi = 1.0 + y;\n lo = 1.0 - hi + y + lo;\n y = (hi + lo) - 1.0;\n }\n return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n const\n N = 1 << EXP_TABLE_BITS,\n N_MASK = N - 1,\n shift = reinterpret(0x4338000000000000) / N; // 0x1.8p52\n\n const\n C1 = reinterpret(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n C2 = reinterpret(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n C3 = reinterpret(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n C4 = reinterpret(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n C5 = reinterpret(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n let ux = reinterpret(x);\n let abstop = u32(ux >> 52) & 0x7ff;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n if (abstop >= 0x409) {\n if (ux == 0xFFF0000000000000) return 0;\n if (abstop >= 0x7FF) return 1.0 + x;\n if (ux >= 0) return Infinity;\n else if (ux >= 0xC090CC0000000000) return 0;\n }\n if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n }\n\n // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n let kd = x + shift;\n let ki = reinterpret(kd);\n kd -= shift; // k/N for int k\n let r = x - kd;\n // 2^(k/N) ~= scale * (1 + tail)\n let idx = usize((ki & N_MASK) << 1);\n let top = ki << (52 - EXP_TABLE_BITS);\n\n let tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof()), 0 << alignof())); // T[idx])\n // This is only a valid scale when -1023*N < k < 1024*N\n let sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top; // T[idx + 1]\n // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r;\n // Without fma the worst case error is 0.5/N ulp larger.\n // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase2(tmp, sbits, ki);\n let scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n // is no spurious underflow here even without fma.\n return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n x = 2^k z\n log2(x) = k + log2(c) + log2(z/c)\n log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log2(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p10 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-64 and\n 3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n 0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n 0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n 0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n 0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n 0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n 0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n 0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n 0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n 0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n 0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n 0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n 0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n 0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n 0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n 0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n 0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n 0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n 0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n 0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n 0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n 0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n 0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n 0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n 0x3FF234563D8615B1, 0xBFC7D6023F800000,\n 0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n 0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n 0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n 0x3FF19453847F2200, 0xBFC162595AFDC000,\n 0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n 0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n 0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n 0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n 0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n 0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n 0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n 0x3FF07325CAC53B83, 0xBFA47A954F770000,\n 0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n 0x3FF03091C1208EA2, 0xBF916A2629780000,\n 0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n 0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n 0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n 0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n 0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n 0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n 0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n 0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n 0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n 0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n 0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n 0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n 0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n 0x3FEAC57026295039, 0x3FD0790AB4678000,\n 0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n 0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n 0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n 0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n 0x3FE920FB3982BCF2, 0x3FD651902050D000,\n 0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n 0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n 0x3FE83C97B658B994, 0x3FD9A80155E16000,\n 0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n 0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n 0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n 0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n 0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n 0x3FE6E00038B95A04, 0x3C88FF8856739326,\n 0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n 0x3FE7600015590E10, 0xBC72FD75B4238341,\n 0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n 0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n 0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n 0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n 0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n 0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n 0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n 0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n 0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n 0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n 0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n 0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n 0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n 0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n 0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n 0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n 0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n 0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n 0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n 0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n 0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n 0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n 0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n 0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n 0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n 0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n 0x3FEE200002F64791, 0x3C89802F09EF62E0,\n 0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n 0x3FEEA00027EDC00C, 0xBC8C848309459811,\n 0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n 0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n 0x3FEF6000260C450A, 0xBC4071002727FFDC,\n 0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n 0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n 0x3FF0200004292367, 0x3C9B7FF365324681,\n 0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n 0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n 0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n 0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n 0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n 0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n 0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n 0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n 0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n 0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n 0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n 0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n 0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n 0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n 0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n 0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n 0x3FF460000D387CB1, 0x3C820837856599A6,\n 0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n 0x3FF4E000043543F3, 0xBC781125ED175329,\n 0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n 0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n 0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n 0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n const\n LO: u64 = 0x3FEEA4AF00000000, // reinterpret(1.0 - 0x1.5b51p-5)\n HI: u64 = 0x3FF0B55900000000; // reinterpret(1.0 + 0x1.6ab2p-5)\n\n const\n InvLn2hi = reinterpret(0x3FF7154765200000), // 0x1.7154765200000p+0\n InvLn2lo = reinterpret(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n const\n B0 = reinterpret(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n B1 = reinterpret(0x3FDEC709DC3A03F7), // 0x1.ec709dc3a03f7p-2\n B2 = reinterpret(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n B3 = reinterpret(0x3FD2776C50F05BE4), // 0x1.2776c50f05be4p-2\n B4 = reinterpret(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n B5 = reinterpret(0x3FCA61761EC4E736), // 0x1.a61761ec4e736p-3\n B6 = reinterpret(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n B7 = reinterpret(0x3FC484D154F01B4A), // 0x1.484d154f01b4ap-3\n B8 = reinterpret(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n B9 = reinterpret(0x3FC0B32F285AEE66); // 0x1.0b32f285aee66p-3\n\n const\n A0 = reinterpret(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n A1 = reinterpret(0x3FDEC709DC3A04BE), // 0x1.ec709dc3a04bep-2\n A2 = reinterpret(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n A3 = reinterpret(0x3FD2776C50034C48), // 0x1.2776c50034c48p-2\n A4 = reinterpret(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n A5 = reinterpret(0x3FCA6225E117F92E); // 0x1.a6225e117f92ep-3\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n // #if __FP_FAST_FMA\n // hi = r * InvLn2hi;\n // lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n // #else\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let hi = rhi * InvLn2hi;\n let lo = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n let r2 = r * r; // rounding error: 0x1p-62\n let r4 = r2 * r2;\n // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n let p = r2 * (B0 + r * B1);\n let y = hi + p;\n lo += hi - y + p;\n lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n return y + lo;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan.\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it.\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & 0xFFF0000000000000);\n\n let invc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG2_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n let kd = k;\n\n // log2(x) = log2(z/c) + log2(c) + k.\n // r ~= z/c - 1, |r| < 1/(2*N).\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N.\n // \tr = __builtin_fma(z, invc, -1.0);\n // \tt1 = r * InvLn2hi;\n // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-65.\n let chi = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T[i].chi;\n let clo = load(LOG2_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T[i].clo;\n\n let r = (z - chi - clo) * invc;\n let rhi = reinterpret(reinterpret(r) & 0xFFFFFFFF00000000);\n let rlo = r - rhi;\n let t1 = rhi * InvLn2hi;\n let t2 = rlo * InvLn2hi + r * InvLn2lo;\n // #endif\n\n // hi + lo = r/ln2 + log2(c) + k\n let t3 = kd + logc;\n let hi = t3 + t1;\n let lo = t3 - hi + t1 + t2;\n\n // log2(r+1) = r/ln2 + r^2*poly(r)\n // Evaluation is optimized assuming superscalar pipelined execution\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = (double)log(c)\n tab2[i].chi = (double)c\n tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n 1) the rounding error in 0x1.8p9 + logc is 0,\n 2) the rounding error in z - chi - clo is < 0x1p-66 and\n 3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data([\n // invc , logc\n 0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n 0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n 0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n 0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n 0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n 0x3FF69147332F0CBA, 0xBFD602D076180000,\n 0x3FF6719F18224223, 0xBFD5A8CA86909000,\n 0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n 0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n 0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n 0x3FF5F66452C65C4C, 0xBFD445923989A800,\n 0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n 0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n 0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n 0x3FF5805612465687, 0xBFD2E9E2EF468000,\n 0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n 0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n 0x3FF52AFF42064583, 0xBFD1E9E129279000,\n 0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n 0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n 0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n 0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n 0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n 0x3FF4880524D48434, 0xBFCFEB224586F000,\n 0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n 0x3FF453D9D3391854, 0xBFCEA4443D103000,\n 0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n 0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n 0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n 0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n 0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n 0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n 0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n 0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n 0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n 0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n 0x3FF34679984DD440, 0xBFC7D68FB4143000,\n 0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n 0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n 0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n 0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n 0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n 0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n 0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n 0x3FF293726014B530, 0xBFC31B996B490000,\n 0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n 0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n 0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n 0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n 0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n 0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n 0x3FF201201DD2FC9B, 0xBFBE370896404000,\n 0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n 0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n 0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n 0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n 0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n 0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n 0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n 0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n 0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n 0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n 0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n 0x3FF11A3028ECB531, 0xBFB10E4698622000,\n 0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n 0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n 0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n 0x3FF0D244632CA521, 0xBFA9A1894012C000,\n 0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n 0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n 0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n 0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n 0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n 0x3FF06AB58C358F19, 0xBF9A55F152528000,\n 0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n 0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n 0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n 0x3FF02865137932A9, 0xBF8419355DAA0000,\n 0x3FF0182427EA7348, 0xBF781203C2EC0000,\n 0x3FF008040614B195, 0xBF60040979240000,\n 0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n 0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n 0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n 0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n 0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n 0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n 0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n 0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n 0x3FEE01E009609A56, 0x3FB07598E598C000,\n 0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n 0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n 0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n 0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n 0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n 0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n 0x3FEC8B266D37086D, 0x3FBD431332E72000,\n 0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n 0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n 0x3FEBF583EEECE73F, 0x3FC147858292B000,\n 0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n 0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n 0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n 0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n 0x3FEB094B211D304A, 0x3FC5933928D1F000,\n 0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n 0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n 0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n 0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n 0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n 0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n 0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n 0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n 0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n 0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n 0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n 0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n 0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n 0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n 0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n 0x3FE87427AA2317FB, 0x3FD13687334BD000,\n 0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n 0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n 0x3FE8060195F40260, 0x3FD2595FD7636800,\n 0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n 0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n 0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n 0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n 0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data([\n // chi , clo\n 0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n 0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n 0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n 0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n 0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n 0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n 0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n 0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n 0x3FE710000E869780, 0x3C7BFF6671097952,\n 0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n 0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n 0x3FE770000F679C90, 0xBC67FC71CD549C74,\n 0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n 0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n 0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n 0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n 0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n 0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n 0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n 0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n 0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n 0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n 0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n 0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n 0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n 0x3FE9300013467BB9, 0x3C7F804E4B980276,\n 0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n 0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n 0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n 0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n 0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n 0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n 0x3FEA10001145B006, 0x3C74FF489958DA56,\n 0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n 0x3FEA500010971D79, 0x3C88FECADD787930,\n 0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n 0x3FEA90001C593352, 0xBC8EBF0284C27612,\n 0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n 0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n 0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n 0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n 0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n 0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n 0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n 0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n 0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n 0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n 0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n 0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n 0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n 0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n 0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n 0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n 0x3FECB0002125219A, 0xBC68FD8E64180E04,\n 0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n 0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n 0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n 0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n 0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n 0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n 0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n 0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n 0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n 0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n 0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n 0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n 0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n 0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n 0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n 0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n 0x3FEED0001A127FA1, 0xBC5002F860565C92,\n 0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n 0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n 0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n 0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n 0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n 0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n 0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n 0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n 0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n 0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n 0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n 0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n 0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n 0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n 0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n 0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n 0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n 0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n 0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n 0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n 0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n 0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n 0x3FF1B000123D3C59, 0x3C997F7980030188,\n 0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n 0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n 0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n 0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n 0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n 0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n 0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n 0x3FF2B00014556313, 0xBC92808233F21F02,\n 0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n 0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n 0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n 0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n 0x3FF350000CA66756, 0x3C957F82228B82BD,\n 0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n 0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n 0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n 0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n 0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n 0x3FF410001532AFF4, 0x3C67F8375F198524,\n 0x3FF4300017478B29, 0x3C8301E672DC5143,\n 0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n 0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n 0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n 0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n 0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n 0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n 0x3FF5100012DC4BD1, 0x3C6004657166A436,\n 0x3FF530001605277A, 0xBC96BFCECE233209,\n 0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n 0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n 0x3FF5900017E61012, 0x3C887EC581AFEF90,\n 0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n 0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n 0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n const\n B0 = reinterpret(0xBFE0000000000000), // -0x1p-1\n B1 = reinterpret(0x3FD5555555555577), // 0x1.5555555555577p-2\n B2 = reinterpret(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n B3 = reinterpret(0x3FC999999995DD0C), // 0x1.999999995dd0cp-3\n B4 = reinterpret(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n B5 = reinterpret(0x3FC24924A344DE30), // 0x1.24924a344de3p-3\n B6 = reinterpret(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n B7 = reinterpret(0x3FBC7184282AD6CA), // 0x1.c7184282ad6cap-4\n B8 = reinterpret(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n B9 = reinterpret(0x3FB78182F7AFD085), // 0x1.78182f7afd085p-4\n B10 = reinterpret(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n const\n A0 = reinterpret(0xBFE0000000000001), // -0x1.0000000000001p-1\n A1 = reinterpret(0x3FD555555551305B), // 0x1.555555551305bp-2\n A2 = reinterpret(0xBFCFFFFFFFEB4590), // -0x1.fffffffeb459p-3\n A3 = reinterpret(0x3FC999B324F10111), // 0x1.999b324f10111p-3\n A4 = reinterpret(0xBFC55575E506C89F); // -0x1.55575e506c89fp-3\n\n const\n LO: u64 = 0x3FEE000000000000,\n HI: u64 = 0x3FF1090000000000;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n Ln2lo = reinterpret(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n Ox1p27 = reinterpret(0x41A0000000000000), // 0x1p27\n Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let ix = reinterpret(x);\n if (ix - LO < HI - LO) {\n let r = x - 1.0;\n let r2 = r * r;\n let r3 = r2 * r;\n let y =\n r3 * (B1 + r * B2 + r2 * B3 +\n r3 * (B4 + r * B5 + r2 * B6 +\n r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n // Worst-case error is around 0.507 ULP\n let w = r * Ox1p27;\n let rhi = r + w - w;\n let rlo = r - rhi;\n w = rhi * rhi * B0; // B[0] == -0.5\n let hi = r + w;\n let lo = r - hi + w;\n lo += B0 * rlo * (rhi + r);\n return y + lo + hi;\n }\n let top = u32(ix >> 48);\n if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n // x < 0x1p-1022 or inf or nan\n if ((ix << 1) == 0) return -1.0 / (x * x);\n if (ix == reinterpret(Infinity)) return x; // log(inf) == inf\n if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n // x is subnormal, normalize it\n ix = reinterpret(x * Ox1p52);\n ix -= u64(52) << 52;\n }\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3FE6000000000000;\n let i = ((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & (u64(0xFFF) << 52));\n\n let invc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 0 << alignof()); // T[i].invc;\n let logc = load(LOG_DATA_TAB1 + (i << (1 + alignof())), 1 << alignof()); // T[i].logc;\n let z = reinterpret(iz);\n\n // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n // r ~= z/c - 1, |r| < 1/(2*N)\n // #if __FP_FAST_FMA\n // \t// rounding error: 0x1p-55/N\n // \tr = __builtin_fma(z, invc, -1.0);\n // #else\n // rounding error: 0x1p-55/N + 0x1p-66\n const chi = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 0 << alignof()); // T2[i].chi\n const clo = load(LOG_DATA_TAB2 + (i << (1 + alignof())), 1 << alignof()); // T2[i].clo\n let r = (z - chi - clo) * invc;\n // #endif\n let kd = k;\n\n // hi + lo = r + log(c) + k*Ln2\n let w = kd * Ln2hi + logc;\n let hi = w + r;\n let lo = w - hi + r + kd * Ln2lo;\n\n // log(x) = lo + (log1p(r) - r) + hi\n let r2 = r * r; // rounding error: 0x1p-54/N^2\n // Worst case error if |y| > 0x1p-5:\n // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n // Worst case error if |y| > 0x1p-4:\n // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n x = 2^k z\n log(x) = k ln2 + log(c) + log(z/c)\n log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n tab[i].invc = 1/c\n tab[i].logc = round(0x1p43*log(c))/0x1p43\n tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n 1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data([\n // invc ,pad, logc , logctail\n 0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n 0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n 0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n 0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n 0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n 0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n 0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n 0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n 0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n 0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n 0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n 0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n 0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n 0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n 0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n 0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n 0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n 0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n 0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n 0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n 0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n 0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n 0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n 0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n 0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n 0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n 0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n 0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n 0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n 0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n 0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n 0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FF0000000000000, 0, 0, 0,\n 0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n 0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n 0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n 0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n 0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n 0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n 0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n 0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n 0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n 0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n 0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n 0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n 0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n 0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n 0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n 0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n 0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n 0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n 0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n 0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n 0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n 0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n 0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n 0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n 0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n 0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n 0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n 0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n 0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n 0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n 0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n 0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n 0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n 0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n 0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n 0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n 0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n 0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n 0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n 0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n 0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n 0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n 0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n 0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n 0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n 0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n 0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n 0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n 0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n 0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n 0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n 0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n let e = iy >> 52 & 0x7FF;\n if (e < 0x3FF ) return 0;\n if (e > 0x3FF + 52) return 2;\n e = u64(1) << (0x3FF + 52 - e);\n if (iy & (e - 1)) return 0;\n if (iy & e ) return 1;\n return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n return xflow(sign, reinterpret(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n const N = 1 << POW_LOG_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n Ln2hi = reinterpret(0x3FE62E42FEFA3800),\n Ln2lo = reinterpret(0x3D2EF35793C76730);\n\n const\n A0 = reinterpret(0xBFE0000000000000),\n A1 = reinterpret(0xBFE5555555555560),\n A2 = reinterpret(0x3FE0000000000006),\n A3 = reinterpret(0x3FE999999959554E),\n A4 = reinterpret(0xBFE555555529A47A),\n A5 = reinterpret(0xBFF2495B9B4845E9),\n A6 = reinterpret(0x3FF0002B8B263FC3);\n\n // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n // The range is split into N subintervals.\n // The ith subinterval contains z and c is near its center.\n let tmp = ix - 0x3fE6955500000000;\n let i = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n let k = tmp >> 52;\n let iz = ix - (tmp & u64(0xFFF) << 52);\n let z = reinterpret(iz);\n let kd = k;\n\n // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n let invc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 0 << alignof()); // tab[i].invc\n let logc = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 2 << alignof()); // tab[i].logc\n let logctail = load(POW_LOG_DATA_TAB + (i << (2 + alignof())), 3 << alignof()); // tab[i].logctail\n\n // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n let zhi = reinterpret((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n let zlo = z - zhi;\n let rhi = zhi * invc - 1.0;\n let rlo = zlo * invc;\n let r = rhi + rlo;\n\n // k * Ln2 + log(c) + r.\n let t1 = kd * Ln2hi + logc;\n let t2 = t1 + r;\n let lo1 = kd * Ln2lo + logctail;\n let lo2 = t1 - t2 + r;\n\n // Evaluation is optimized assuming superscalar pipelined execution.\n let ar = A0 * r; // A[0] = -0.5\n let ar2 = r * ar;\n let ar3 = r * ar2;\n // k * Ln2 + log(c) + r + A[0] * r * r.\n let arhi = A0 * rhi;\n let arhi2 = rhi * arhi;\n let hi = t2 + arhi2;\n let lo3 = rlo * (ar + arhi);\n let lo4 = t2 - hi + arhi2;\n\n // p = log1p(r) - r - A[0] * r * r.\n let p = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n let lo = lo1 + lo2 + lo3 + lo4 + p;\n let y = hi + lo;\n log_tail = hi - y + lo;\n\n return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n const N = 1 << EXP_TABLE_BITS;\n const N_MASK = N - 1;\n\n const\n InvLn2N = reinterpret(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n NegLn2hiN = reinterpret(0xBF762E42FEFA0000), // -0x1.62e42fefa0000p-8\n NegLn2loN = reinterpret(0xBD0CF79ABC9E3B3A), // -0x1.cf79abc9e3b3ap-47\n shift = reinterpret(0x4338000000000000); // 0x1.8p52\n\n const\n C2 = reinterpret(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n C3 = reinterpret(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n C4 = reinterpret(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n C5 = reinterpret(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n let abstop: u32;\n let ki: u64, top: u64, sbits: u64;\n let idx: usize;\n // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n let ux = reinterpret(x);\n abstop = u32(ux >> 52) & 0x7FF;\n if (abstop - 0x3C9 >= 0x03F) {\n if (abstop - 0x3C9 >= 0x80000000) {\n // Avoid spurious underflow for tiny x.\n // Note: 0 is common input.\n return select(-1.0, 1.0, sign_bias);\n }\n if (abstop >= 0x409) { // top12(1024.0)\n // Note: inf and nan are already handled.\n return ux < 0\n ? uflow(sign_bias)\n : oflow(sign_bias);\n }\n // Large x is special cased below.\n abstop = 0;\n }\n\n // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n z = InvLn2N * x;\n\n // #if TOINT_INTRINSICS\n // kd = roundtoint(z);\n // ki = converttoint(z);\n // #elif EXP_USE_TOINT_NARROW\n // // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n // kd = eval_as_double(z + shift);\n // ki = asuint64(kd) >> 16;\n // kd = (double_t)(int32_t)ki;\n // #else\n // z - kd is in [-1, 1] in non-nearest rounding modes\n kd = z + shift;\n ki = reinterpret(kd);\n kd -= shift;\n // #endif\n r = x + kd * NegLn2hiN + kd * NegLn2loN;\n // The code assumes 2^-200 < |xtail| < 2^-8/N\n r += xtail;\n // 2^(k/N) ~= scale * (1 + tail)\n idx = usize((ki & N_MASK) << 1);\n top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n tail = reinterpret(load(EXP_DATA_TAB + (idx << alignof())));\n // This is only a valid scale when -1023*N < k < 1024*N\n sbits = load(EXP_DATA_TAB + (idx << alignof()), 1 << alignof()) + top;\n // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n // Evaluation is optimized assuming superscalar pipelined execution.\n r2 = r * r;\n // Without fma the worst case error is 0.25/N ulp larger.\n // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n if (abstop == 0) return specialcase(tmp, sbits, ki);\n scale = reinterpret(sbits);\n // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n // is no spurious underflow here even without fma.\n return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n const Ox1p52 = reinterpret(0x4330000000000000); // 0x1p52\n\n let sign_bias: u32 = 0;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n let topx = ix >> 52;\n let topy = iy >> 52;\n\n if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n // Special cases: (x < 0x1p-126 or inf or nan) or\n // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n if (zeroinfnan(iy)) {\n if ((iy << 1) == 0) return 1.0;\n if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n return y * y;\n }\n if (zeroinfnan(ix)) {\n let x2 = x * x;\n if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n return iy < 0 ? 1 / x2 : x2;\n }\n // Here x and y are non-zero finite\n if (ix < 0) {\n // Finite x < 0\n let yint = checkint(iy);\n if (yint == 0) return (x - x) / (x - x);\n if (yint == 1) sign_bias = SIGN_BIAS;\n ix &= 0x7FFFFFFFFFFFFFFF;\n topx &= 0x7FF;\n }\n if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n // Note: sign_bias == 0 here because y is not odd.\n if (ix == 0x3FF0000000000000) return 1;\n if ((topy & 0x7FF) < 0x3BE) return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n }\n if (topx == 0) {\n // Normalize subnormal x so exponent becomes negative.\n ix = reinterpret(x * Ox1p52);\n ix &= 0x7FFFFFFFFFFFFFFF;\n ix -= u64(52) << 52;\n }\n }\n\n let hi = log_inline(ix);\n let lo = log_tail;\n let ehi: f64, elo: f64;\n // #if __FP_FAST_FMA\n // ehi = y * hi;\n // elo = y * lo + __builtin_fma(y, hi, -ehi);\n // #else\n let yhi = reinterpret(iy & 0xFFFFFFFFF8000000);\n let ylo = y - yhi;\n let lhi = reinterpret(reinterpret(hi) & 0xFFFFFFFFF8000000);\n let llo = hi - lhi + lo;\n ehi = yhi * lhi;\n elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n // #endif\n return exp_inline(ehi, elo, sign_bias);\n}\n","import {\n itoa32,\n utoa32,\n itoa64,\n utoa64,\n dtoa,\n itoa_buffered,\n dtoa_buffered,\n MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data([\n 18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n 41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n 68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n 93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n 17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n 17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n 119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n 16,16,125,16,16,16,\n 16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n 255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n 251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n 255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n 255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n 31,254,225,255,\n 159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n 255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n 1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n 255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n 197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n 94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n 159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n 255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n 207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n 253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n 251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n 0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n 0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n 31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n 255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n 255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n 127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n 7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n 255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n 255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n 255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n 63,\n 0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n 255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n 127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n 255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n 255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n 128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n 255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n 224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n 0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n 255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n 255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n 255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n 255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,\n 31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n 255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n 0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n 255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n 255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n 255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n 255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n 255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n 126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n 255,\n 15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n 252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n 254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n 252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n 0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n 255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n 255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n 127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n 254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n 255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n 0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n 0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n 0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n 255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n 255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n 127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n 253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n 255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n 3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n 7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n 255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n 127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n 255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n 255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n 255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n 0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,\n 0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n 255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n 255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n 255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n 127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n 223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n 255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n 247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n 255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n 128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n 3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n 255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n 132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data([\n 18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n 24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n 29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n 16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n 16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n 16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n 255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n 0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n 255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n 255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n 191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n 255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n 132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n 255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n 255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n 255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n 255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n 0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n 254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n 255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n 255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n 95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n 253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n 255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n 15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data([\n 18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n 33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n 43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n 47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n 16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n 66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n 16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n 88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n 16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n 255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n 0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n 1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n 0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n 0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n 254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n 6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n 190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n 4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n 193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n 3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n 0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n 0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n 0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n 0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n 0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n 0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n 0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n 0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n 15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n 0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n 0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n 255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n 3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n 0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n 0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n 0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n 0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n 0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n 255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n 128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n 0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n 2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n 255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n 0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n 0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n 0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n 3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n 3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n 0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n 0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n 0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n 0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n 0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n 231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n 0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 91,92,93,94,95,96,\n 97,98,99,100,101,102,103,104,105,106,107,108,109,\n 110,111,112,113,114,115,116,117,118,119,120,121,122,\n 123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data([\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n 64,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 91,92,93,94,95,96,\n 65,66,67,68,69,70,71,72,73,74,75,76,77,\n 78,79,80,81,82,83,84,85,86,87,88,89,90,\n 123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data([\n 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n 1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n PERCENT = 0x25,\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n I = 0x49,\n N = 0x4E,\n O = 0x4F,\n X = 0x58,\n Z = 0x5A,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n n = 0x6E,\n o = 0x6F,\n u = 0x75,\n x = 0x78,\n z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n if (c < 0x1680) { // < (1)\n // , , , , , and \n // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n }\n if (c - 0x2000 <= 0x200A - 0x2000) return true;\n switch (c) {\n case 0x1680: // (1)\n case 0x2028: // (2)\n case 0x2029: // \n case 0x202F: // \n case 0x205F: // \n case 0x3000: // \n case 0xFEFF: return true; // \n }\n return false;\n}\n\nexport function isAlpha(c: u32): bool {\n if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n if (c < 0x20000) {\n // @ts-ignore: cast\n return stagedBinaryLookup(ALPHA_TABLE, c);\n }\n return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n // @ts-ignore: cast\n return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n // @ts-ignore: cast\n return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n const lookaheadLimit = 30; // max lookahead limit\n let found = false;\n let pos = index;\n let minPos = max(0, pos - lookaheadLimit);\n while (pos > minPos) {\n let c = codePointBefore(buffer, pos);\n if (!isCaseIgnorable(c)) {\n if (isCased(c)) {\n found = true;\n } else {\n return false;\n }\n }\n pos -= isize(c >= 0x10000) + 1;\n }\n if (!found) return false;\n pos = index + 1;\n let maxPos = min(pos + lookaheadLimit, len);\n while (pos < maxPos) {\n let c = load(buffer + (pos << 1));\n if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n let c1 = load(buffer + (pos << 1), 2);\n if ((c1 & 0xFC00) == 0xDC00) {\n c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n }\n }\n if (!isCaseIgnorable(c)) {\n return !isCased(c);\n }\n pos += isize(c >= 0x10000) + 1;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n if (index <= 0) return -1;\n let c = load(buffer + (index - 1 << 1));\n if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n let c1 = load(buffer + (index - 2 << 1));\n if ((c1 & 0xFC00) == 0xD800) {\n return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n }\n }\n return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n return ((load(table + (load(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n let ptr1 = changetype(str1) + (index1 << 1);\n let ptr2 = changetype(str2) + (index2 << 1);\n if (ASC_SHRINK_LEVEL < 2) {\n if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n do {\n if (load(ptr1) != load(ptr2)) break;\n ptr1 += 8;\n ptr2 += 8;\n len -= 4;\n } while (len >= 4);\n }\n }\n while (len--) {\n let a = load(ptr1);\n let b = load(ptr2);\n if (a != b) return a - b;\n ptr1 += 2;\n ptr2 += 2;\n }\n return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c | u32(isUpper8(c)) << 5;\n } else {\n return load(LOWER127 + c);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return c & ~(u32(isLower8(c)) << 5);\n } else {\n return load(UPPER127 + c);\n }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol(str: string, radix: i32 = 0): T {\n let len = str.length;\n if (!len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n\n let ptr = changetype(str) /* + HEAD -> offset */;\n let code = load(ptr);\n\n // trim white spaces\n while (isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n // determine sign\n // @ts-ignore\n let sign: T = 1;\n if (code == CharCode.MINUS || code == CharCode.PLUS) {\n if (!--len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n if (code == CharCode.MINUS) {\n // @ts-ignore: type\n sign = -1;\n }\n code = load(ptr += 2);\n }\n\n // See https://tc39.es/ecma262/#sec-parseint-string-radix\n if (radix) {\n if (radix < 2 || radix > 36) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n // handle case as parseInt(\"0xFF\", 16) by spec\n if (radix == 16) {\n if (\n len > 2 &&\n code == CharCode._0 &&\n (load(ptr, 2) | 32) == CharCode.x\n ) {\n ptr += 4; len -= 2;\n }\n }\n } else {\n // determine radix by literal prefix\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr, 2) | 32) {\n case CharCode.b: {\n ptr += 4; len -= 2;\n radix = 2;\n break;\n }\n case CharCode.o: {\n ptr += 4; len -= 2;\n radix = 8;\n break;\n }\n case CharCode.x: {\n ptr += 4; len -= 2;\n radix = 16;\n break;\n }\n }\n }\n if (!radix) radix = 10;\n }\n\n // calculate value\n // @ts-ignore: type\n let num: T = 0;\n let initial = len - 1;\n while (len--) {\n code = load(ptr);\n if (code - CharCode._0 < 10) {\n code -= CharCode._0;\n } else if (code - CharCode.A <= (CharCode.Z - CharCode.A)) {\n code -= CharCode.A - 10;\n } else if (code - CharCode.a <= (CharCode.z - CharCode.a)) {\n code -= CharCode.a - 10;\n }\n if (code >= radix) {\n if (initial == len) {\n if (isFloat()) {\n // @ts-ignore: cast\n return NaN;\n } else {\n // @ts-ignore: cast\n return 0;\n }\n }\n break;\n }\n // @ts-ignore: type\n num = num * radix + code;\n ptr += 2;\n }\n // @ts-ignore: type\n return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n let len = str.length;\n if (!len) return NaN;\n\n let ptr = changetype(str);\n let code = load(ptr);\n\n let sign = 1.0;\n // skip white spaces\n while (len && isSpace(code)) {\n code = load(ptr += 2);\n --len;\n }\n if (!len) return NaN;\n\n // try parse '-' or '+'\n if (code == CharCode.MINUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return NaN;\n code = load(ptr += 2);\n }\n\n // try parse Infinity\n if (len >= 8 && code == CharCode.I) {\n if (\n load(ptr, 0) == 0x690066006E0049 && // ifnI\n load(ptr, 8) == 0x7900740069006E // ytin\n ) {\n return Infinity * sign;\n }\n return NaN;\n }\n // validate next symbol\n if (code != CharCode.DOT && (code - CharCode._0) >= 10) {\n return NaN;\n }\n let savedPtr = ptr;\n // skip zeros\n while (code == CharCode._0) {\n code = load(ptr += 2);\n --len;\n }\n if (len <= 0) return 0.0 * sign;\n const capacity = 19; // int(64 * 0.3010)\n let pointed = false;\n let consumed = 0;\n let position = 0;\n let x: u64 = 0;\n if (code == CharCode.DOT) {\n let noDigits = !(savedPtr - ptr);\n ptr += 2; --len;\n if (!len && noDigits) return NaN;\n for (pointed = true; (code = load(ptr)) == CharCode._0; --position, ptr += 2) --len;\n if (len <= 0) return 0.0 * sign;\n if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n }\n for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n if (digit < 10) {\n x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n ++consumed;\n } else {\n position = consumed;\n pointed = true;\n }\n if (!--len) break;\n code = load(ptr += 2);\n }\n\n if (!pointed) position = consumed;\n return copysign(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n let size: usize = str.length << 1;\n let offset: usize = 0;\n if (size > 8) {\n // try trim end whitespaces first\n while (size && isSpace(load(changetype(str) + size - 2))) size -= 2;\n if (size > 8) {\n // trim start whitespaces\n while (offset < size && isSpace(load(changetype(str) + offset))) offset += 2;\n size -= offset;\n }\n }\n if (size != 8) return false;\n // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n return load(changetype(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) return select(\"true\", \"false\", load(dataStart));\n\n let sepLen = separator.length;\n let valueLen = 5; // max possible length of element len(\"false\")\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: bool;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + i);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + lastIndex);\n valueLen = 4 + i32(!value);\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(select(\"true\", \"false\", value)),\n valueLen << 1\n );\n offset += valueLen;\n\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinIntegerArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n let value = load(dataStart);\n if (isSigned()) {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(itoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(itoa64(value, 10));\n }\n } else {\n if (sizeof() <= 4) {\n // @ts-ignore: type\n return changetype(utoa32(value, 10));\n } else {\n // @ts-ignore: type\n return changetype(utoa64(value, 10));\n }\n }\n }\n\n let sepLen = separator.length;\n const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned());\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += itoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinFloatArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n return changetype(dtoa(\n // @ts-ignore: type\n load(dataStart))\n );\n }\n\n const valueLen = MAX_DOUBLE_LENGTH;\n let sepLen = separator.length;\n let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n let result = changetype(__new(estLen << 1, idof()));\n let offset = 0;\n let value: T;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n offset += dtoa_buffered(changetype(result) + (offset << 1), value);\n if (estLen > offset) return result.substring(0, offset);\n return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n if (!lastIndex) {\n // @ts-ignore: type\n return load(dataStart) || \"\";\n }\n let estLen = 0;\n let value: string;\n for (let i = 0; i < length; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) estLen += value.length;\n }\n let offset = 0;\n let sepLen = separator.length;\n let result = changetype(__new((estLen + sepLen * lastIndex) << 1, idof()));\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n if (changetype(value) != 0) {\n let valueLen = value.length;\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n valueLen << 1\n );\n offset += valueLen;\n }\n if (sepLen) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(separator),\n sepLen << 1\n );\n offset += sepLen;\n }\n }\n value = load(dataStart + (lastIndex << alignof()));\n if (changetype(value) != 0) {\n memory.copy(\n changetype(result) + (offset << 1),\n changetype(value),\n value.length << 1\n );\n }\n return result;\n}\n\nexport function joinReferenceArray(dataStart: usize, length: i32, separator: string): string {\n let lastIndex = length - 1;\n if (lastIndex < 0) return \"\";\n let value: T;\n if (!lastIndex) {\n value = load(dataStart);\n // @ts-ignore: type\n return value != null ? value.toString() : \"\";\n }\n let result = \"\";\n let sepLen = separator.length;\n for (let i = 0; i < lastIndex; ++i) {\n value = load(dataStart + (i << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n if (sepLen) result += separator;\n }\n value = load(dataStart + (lastIndex << alignof()));\n // @ts-ignore: type\n if (value != null) result += value.toString();\n return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n if (!significand || exp < -342) return 0;\n if (exp > 308) return Infinity;\n // Try use fast path\n // Use fast path for string-to-double conversion if possible\n // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n // Simple integer\n let significandf = significand;\n if (!exp) return significandf;\n if (exp > 22 && exp <= 22 + 15) {\n significandf *= pow10(exp - 22);\n exp = 22;\n }\n if (significand <= 9007199254740991 && abs(exp) <= 22) {\n if (exp > 0) return significandf * pow10(exp);\n return significandf / pow10(-exp);\n } else if (exp < 0) {\n return scaledown(significand, exp);\n } else {\n return scaleup(significand, exp);\n }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n const scale = reinterpret(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n let shift = clz(significand);\n significand <<= shift;\n shift = exp - shift;\n\n for (; exp <= -14; exp += 14) {\n let q = significand / denom;\n let r = significand % denom;\n let s = clz(q);\n significand = (q << s) + nearest(scale * (r << (s - 18)));\n shift -= s;\n }\n let b = ipow32(5, -exp);\n let q = significand / b;\n let r = significand % b;\n let s = clz(q);\n significand = (q << s) + (reinterpret(reinterpret(r) + (s << 52)) / b);\n shift -= s;\n\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n let shift = ctz(significand);\n significand >>= shift;\n shift += exp;\n\n __fixmulShift = shift;\n for (; exp >= 13; exp -= 13) {\n significand = fixmul(significand, coeff);\n }\n significand = fixmul(significand, ipow32(5, exp));\n shift = __fixmulShift;\n return NativeMath.scalbn(significand, shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n let sign = 1, magnitude = 0;\n let code = load(ptr);\n // check code is 'e' or 'E'\n if ((code | 32) != CharCode.e) return 0;\n\n if (!--len) return 0;\n code = load(ptr += 2);\n if (code == CharCode.MINUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n // skip zeros\n while (code == CharCode._0) {\n if (!--len) return 0;\n code = load(ptr += 2);\n }\n for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n if (magnitude >= 3200) return sign * 3200;\n magnitude = 10 * magnitude + digit;\n code = load(ptr += 2);\n --len;\n }\n return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n let low = (a & 0xFFFFFFFF) * b;\n let high = (a >> 32) * b + (low >> 32);\n let overflow = (high >> 32);\n let space = clz(overflow);\n let revspace: u64 = 32 - space;\n __fixmulShift += revspace;\n return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n // argument `n` should bounds in [0, 22] range\n return load(POWERS10 + (n << alignof()));\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n let ptr = __rtti_base;\n if (id > load(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n return changetype(ptr + sizeof() + id * offsetof()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n let buffer = __new(size, id);\n if (data) memory.copy(buffer, data, size);\n return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n let bufferSize = length << alignLog2;\n // make sure `buffer` is tracked by the shadow stack\n let buffer = changetype(__newBuffer(bufferSize, idof(), data));\n // ...since allocating the array may trigger GC steps\n let array = __new(offsetof(), id);\n store(array, changetype(buffer), offsetof(\"buffer\"));\n __link(array, changetype(buffer), false);\n store(array, changetype(buffer), offsetof(\"dataStart\"));\n store(array, bufferSize, offsetof(\"byteLength\"));\n store(array, length, offsetof(\"length_\"));\n return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n [key: number]: i8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): i8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): i8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: i8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR()): Int8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n toString(): string {\n return this.join();\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, value);\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n [key: number]: u8;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength;\n }\n\n @operator(\"[]\")\n private __get(index: i32): u8 {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u8 {\n return load(this.dataStart + index);\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + index, ~(value >> 31) & (((255 - value) >> 31) | value));\n }\n\n at(index: i32): u8 {\n let len = this.byteLength;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + index);\n }\n\n includes(searchElement: u8, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n value = ~(value >> 31) & (((255 - value) >> 31) | value);\n FILL(this.dataStart, this.length, u8(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR()): Uint8ClampedArray {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SLICE(this, begin, end);\n }\n\n subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return SUBARRAY(this, start, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint8ClampedArray {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int16Array extends ArrayBufferView {\n [key: number]: i16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR()): Int16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n [key: number]: u16;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u16 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u16 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: native): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: native): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u16 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u16, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n FILL(this.dataStart, this.length, u16(value), start, end);\n return this;\n }\n\n sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR()): Uint16Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint16Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int32Array extends ArrayBufferView {\n [key: number]: i32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n FILL(this.dataStart, this.length, u32(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR()): Int32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n [key: number]: u32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR()): Uint32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Int64Array extends ArrayBufferView {\n [key: number]: i64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): i64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): i64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: i64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: i64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): i64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: i64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n FILL(this.dataStart, this.length, u64(value), start, end);\n return this;\n }\n\n sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR()): Int64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Int64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n [key: number]: u64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): u64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): u64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: u64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: u64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): u64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: u64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR()): Uint64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Uint64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinIntegerArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float32Array extends ArrayBufferView {\n [key: number]: f32;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f32 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f32 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f32): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f32): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f32 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f32, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR()): Float32Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float32Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\nexport class Float64Array extends ArrayBufferView {\n [key: number]: f64;\n\n // @ts-ignore: decorator\n @lazy\n static readonly BYTES_PER_ELEMENT: i32 = sizeof();\n\n constructor(length: i32) {\n super(length, alignof());\n }\n\n get length(): i32 {\n return this.byteLength >>> alignof();\n }\n\n @operator(\"[]\")\n private __get(index: i32): f64 {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n @unsafe @operator(\"{}\")\n private __uget(index: i32): f64 {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\")\n private __set(index: i32, value: f64): void {\n if (index >= this.byteLength >>> alignof()) throw new RangeError(E_INDEXOUTOFRANGE);\n store(this.dataStart + (index << alignof()), value);\n }\n\n @unsafe @operator(\"{}=\")\n private __uset(index: i32, value: f64): void {\n store(this.dataStart + (index << alignof()), value);\n }\n\n at(index: i32): f64 {\n let len = this.byteLength >>> alignof();\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n return load(this.dataStart + (index << alignof()));\n }\n\n includes(searchElement: f64, fromIndex: i32 = 0): bool {\n return INCLUDES(this, searchElement, fromIndex);\n }\n\n indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n return INDEX_OF(this, searchElement, fromIndex);\n }\n\n lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n return LAST_INDEX_OF(this, searchElement, fromIndex);\n }\n\n fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n FILL(this.dataStart, this.length, value, start, end);\n return this;\n }\n\n sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR()): Float64Array {\n SORT(this.dataStart, this.length, comparator);\n return this;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SLICE(this, begin, end);\n }\n\n subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n return SUBARRAY(this, begin, end);\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n return COPY_WITHIN(this, target, start, end);\n }\n\n reduce(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE(this, fn, initialValue);\n }\n\n reduceRight(\n fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n initialValue: T,\n ): T {\n return REDUCE_RIGHT(this, fn, initialValue);\n }\n\n map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n return MAP(this, fn);\n }\n\n filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n return FILTER(this, fn);\n }\n\n findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_INDEX(this, fn);\n }\n\n findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n return FIND_LAST_INDEX(this, fn);\n }\n\n some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return SOME(this, fn);\n }\n\n every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n return EVERY(this, fn);\n }\n\n forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n FOREACH(this, fn);\n }\n\n reverse(): Float64Array {\n REVERSE(this.dataStart, this.length);\n return this;\n }\n\n join(separator: string = \",\"): string {\n return joinFloatArray(this.dataStart, this.length, separator);\n }\n\n set>(source: U, offset: i32 = 0): void {\n SET(this, source, offset);\n }\n\n toString(): string {\n return this.join();\n }\n\n static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n return WRAP(buffer, byteOffset, length);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE(\n array: TArray,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = instantiate(len);\n memory.copy(\n slice.dataStart,\n array.dataStart + (start << alignof()),\n len << alignof()\n );\n return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY(\n array: TArray,\n begin: i32,\n end: i32\n): TArray {\n let len = array.length;\n begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n end = max(end, begin);\n\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(array.buffer);\n store(changetype(out), buf, offsetof(\"buffer\"));\n __link(changetype(out), buf, false);\n store(changetype(out), array.dataStart + (begin << alignof()), offsetof(\"dataStart\"));\n store(changetype(out), (end - begin) << alignof(), offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN(\n array: TArray,\n target: i32,\n start: i32,\n end: i32\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n end = min(end, len);\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy(\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT(\n array: TArray,\n fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n initialValue: TRet\n): TRet {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; i--) {\n initialValue = fn(initialValue, load(ptr + (i << alignof())), i, array);\n }\n return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n let len = array.length;\n let ptr = array.dataStart;\n\n let byteLength = len << alignof();\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(byteLength, idof()));\n for (let i = 0; i < len; i++) {\n store(\n changetype(buf) + (i << alignof()),\n fn(load(ptr + (i << alignof())), i, array)\n );\n }\n store(changetype(out), changetype(buf), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buf), false);\n store(changetype(out), changetype(buf), offsetof(\"dataStart\"));\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER(\n array: TArray,\n fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n let len = array.length;\n let out = changetype(__new(offsetof(), idof()));\n let buf = changetype(__new(len << alignof(), idof()));\n let dataStart = array.dataStart;\n let j: usize = 0;\n for (let i = 0; i < len; i++) {\n let value = load(dataStart + (i << alignof()));\n if (fn(value, i, array)) {\n store(\n changetype(buf) + (j++ << alignof()),\n value\n );\n }\n }\n // shrink output buffer\n let byteLength = j << alignof();\n let data = __renew(changetype(buf), byteLength);\n store(changetype(out), data, offsetof(\"buffer\"));\n __link(changetype(out), data, false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), data, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n let ptr = array.dataStart;\n for (let i = array.length - 1; i >= 0; --i) {\n if (fn(load(ptr + (i << alignof())), i, array)) return i;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): bool {\n if (isFloat()) {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return false;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n let elem = load(dataStart + (index << alignof()));\n // @ts-ignore\n if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n ++index;\n }\n return false;\n } else {\n return INDEX_OF(array, searchElement, fromIndex) >= 0;\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0 || index >= len) return -1;\n if (index < 0) index = max(len + index, 0);\n let dataStart = array.dataStart;\n while (index < len) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n ++index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF(\n array: TArray,\n searchElement: T,\n fromIndex: i32,\n): i32 {\n let index: isize = fromIndex;\n let len: isize = array.length;\n if (len == 0) return -1;\n if (index < 0) index = len + index; // no need to clamp\n else if (index >= len) index = len - 1;\n let dataStart = array.dataStart;\n while (index >= 0) {\n if (load(dataStart + (index << alignof())) == searchElement) return index;\n --index;\n }\n return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) return true;\n }\n return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n if (fn(load(ptr + (i << alignof())), i, array)) continue;\n return false;\n }\n return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH(\n array: TArray,\n fn: (value: T, index: i32, array: TArray) => void,\n): void {\n let ptr = array.dataStart;\n for (let i = 0, k = array.length; i < k; i++) {\n fn(load(ptr + (i << alignof())), i, array);\n }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP(\n buffer: ArrayBuffer,\n byteOffset: i32 = 0,\n len: i32 = -1\n): TArray {\n let byteLength: i32;\n let bufferByteLength = buffer.byteLength;\n const mask: u32 = sizeof() - 1;\n if (i32(byteOffset > bufferByteLength) | (byteOffset & mask)) {\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n if (len < 0) {\n if (len == -1) {\n if (bufferByteLength & mask) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n byteLength = bufferByteLength - byteOffset;\n } else {\n throw new RangeError(E_INVALIDLENGTH);\n }\n } else {\n byteLength = len << alignof();\n if (byteOffset + byteLength > bufferByteLength) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n }\n let out = changetype(__new(offsetof(), idof()));\n store(changetype(out), changetype(buffer), offsetof(\"buffer\"));\n __link(changetype(out), changetype(buffer), false);\n store(changetype(out), byteLength, offsetof(\"byteLength\"));\n store(changetype(out), changetype(buffer) + byteOffset, offsetof(\"dataStart\"));\n return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n TArray extends ArrayLike,\n UArray extends ArrayLike\n>(\n target: TArray,\n source: UArray,\n offset: i32 = 0\n): void {\n // need to assert at compile time that U is not a reference or a function\n if (isReference>()) {\n ERROR(E_NOTIMPLEMENTED);\n }\n let sourceLen = source.length;\n if (offset < 0 || sourceLen + offset > target.length) {\n // offset is out of bounds\n throw new RangeError(E_INDEXOUTOFRANGE);\n }\n // @ts-ignore: dataStart\n let targetStart = target.dataStart + (offset << (alignof>()));\n // @ts-ignore: dataStart\n let sourceStart = source.dataStart;\n // if the types align and match, use memory.copy() instead of manual loop\n if (\n isInteger>() == isInteger>() &&\n alignof>() == alignof>() &&\n !(isSigned>() && target instanceof Uint8ClampedArray)\n ) {\n memory.copy(targetStart, sourceStart, sourceLen << (alignof>()));\n } else {\n for (let i = 0; i < sourceLen; i++) {\n let ptr = targetStart + (i << (alignof>()));\n let value = load>(sourceStart + (i << (alignof>())));\n // if TArray is Uint8ClampedArray, then values must be clamped\n if (target instanceof Uint8ClampedArray) {\n if (isFloat>()) {\n store>(ptr,\n isFinite>(value)\n ? >max>(0, min>(255, value))\n : 0\n );\n } else {\n if (!isSigned>()) {\n store>(ptr, min>(255, value));\n } else if (sizeof>() <= 4) {\n store>(ptr, ~(value >> 31) & (((255 - value) >> 31) | value));\n } else {\n store>(ptr, ~(value >> 63) & (((255 - value) >> 63) | value));\n }\n }\n } else {\n if (isFloat>() && !isFloat>()) {\n store>(ptr, isFinite>(value) ? >value : 0);\n } else {\n store>(ptr, >value);\n }\n }\n }\n }\n}\n","import { compareImpl } from \"./string\";\n\ntype Comparator = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR(): Comparator {\n if (isInteger()) {\n if (isSigned() && sizeof() <= 4) {\n return (a, b) => i32(a) - i32(b);\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n } else if (isFloat()) {\n if (sizeof() == 4) {\n return (a, b) => {\n let ia = reinterpret(f32(a));\n let ib = reinterpret(f32(b));\n ia ^= ia >> 31 >>> 1;\n ib ^= ib >> 31 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n } else {\n return (a, b) => {\n let ia = reinterpret(f64(a));\n let ib = reinterpret(f64(b));\n ia ^= ia >> 63 >>> 1;\n ib ^= ib >> 63 >>> 1;\n return i32(ia > ib) - i32(ia < ib);\n };\n }\n } else if (isString()) {\n return (a, b) => {\n if (\n changetype(a) == changetype(b) ||\n changetype(a) == 0 ||\n changetype(b) == 0\n ) return 0;\n let alen = changetype(a).length;\n let blen = changetype(b).length;\n if (!(alen | blen)) return 0;\n if (!alen) return -1;\n if (!blen) return 1;\n let res = compareImpl(\n changetype(a), 0,\n changetype(b), 0,\n min(alen, blen)\n );\n return res ? res : alen - blen;\n };\n } else {\n return (a, b) => i32(a > b) - i32(a < b);\n }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT(\n ptr: usize,\n len: i32,\n comparator: Comparator\n): void {\n if (len <= INSERTION_SORT_THRESHOLD) {\n if (len <= 1) return;\n if (ASC_SHRINK_LEVEL < 1) {\n switch (len) {\n case 3: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n a = select(a, b, c);\n b = load(ptr, 2 << alignof());\n c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 1 << alignof());\n store(ptr, select(a, b, c), 2 << alignof());\n }\n case 2: {\n let a = load(ptr, 0);\n let b = load(ptr, 1 << alignof());\n let c = comparator(a, b) > 0;\n store(ptr, select(b, a, c), 0);\n store(ptr, select(a, b, c), 1 << alignof());\n return;\n }\n }\n }\n insertionSort(ptr, 0, len - 1, 0, comparator);\n return;\n }\n\n let lgPlus2 = log2u(len) + 2;\n let lgPlus2Size = lgPlus2 << alignof();\n let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n let leftRunEndBuf = leftRunStartBuf + lgPlus2Size;\n\n for (let i: u32 = 0; i < lgPlus2; ++i) {\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n\n let buffer = __alloc(len << alignof());\n\n let hi = len - 1;\n let endA = extendRunRight(ptr, 0, hi, comparator);\n let lenA = endA + 1;\n\n if (lenA < MIN_RUN_LENGTH) {\n endA = min(hi, MIN_RUN_LENGTH - 1);\n insertionSort(ptr, 0, endA, lenA, comparator);\n }\n\n let top: u32 = 0, startA = 0;\n while (endA < hi) {\n let startB = endA + 1;\n let endB = extendRunRight(ptr, startB, hi, comparator);\n let lenB = endB - startB + 1;\n\n if (lenB < MIN_RUN_LENGTH) {\n endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n insertionSort(ptr, startB, endB, lenB, comparator);\n }\n\n let k = nodePower(0, hi, startA, startB, endB);\n\n for (let i = top; i > k; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n endA,\n buffer,\n comparator\n );\n startA = start;\n store(leftRunStartBuf + (i << alignof()), EMPTY);\n }\n }\n\n store(leftRunStartBuf + (k << alignof()), startA);\n store(leftRunEndBuf + (k << alignof()), endA);\n startA = startB;\n endA = endB;\n top = k;\n }\n\n for (let i = top; i != 0; --i) {\n let start = load(leftRunStartBuf + (i << alignof()));\n if (start != EMPTY) {\n mergeRuns(\n ptr,\n start,\n load(leftRunEndBuf + (i << alignof())) + 1,\n hi,\n buffer,\n comparator\n );\n }\n }\n // dealloc aux buffers\n __free(buffer);\n __free(leftRunStartBuf);\n}\n\nfunction insertionSort(\n ptr: usize,\n left: i32,\n right: i32,\n presorted: i32,\n comparator: Comparator\n): void {\n if (ASC_SHRINK_LEVEL >= 1) {\n // slightly improved original insertion sort\n for (let i = left + presorted; i <= right; ++i) {\n let j = i - 1;\n let a = load(ptr + (i << alignof()));\n while (j >= left) {\n let b = load(ptr + (j << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (j << alignof()), b, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), a, 1 << alignof());\n }\n } else {\n // even-odd two-way insertion sort which allow increase minRunLen\n let range = right - left + 1;\n let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n for (; i <= right; i += 2) {\n let a = load(ptr + (i << alignof()), 0);\n let b = load(ptr + (i << alignof()), 1 << alignof());\n let min = b, max = a;\n if (comparator(a, b) <= 0) {\n min = a, max = b;\n }\n let j = i - 1;\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, max) > 0) {\n store(ptr + (j << alignof()), a, 2 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), max, 2 << alignof());\n while (j >= left) {\n a = load(ptr + (j << alignof()));\n if (comparator(a, min) > 0) {\n store(ptr + (j << alignof()), a, 1 << alignof()); --j;\n } else break;\n }\n store(ptr + (j << alignof()), min, 1 << alignof());\n }\n }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n let n: u64 = right - left + 1;\n let s = startB - (left << 1);\n let l = startA + s;\n let r = endB + s + 1;\n let a = (l << 30) / n;\n let b = (r << 30) / n;\n return clz((a ^ b));\n}\n\nfunction extendRunRight(\n ptr: usize,\n i: i32,\n right: i32,\n comparator: Comparator\n): i32 {\n if (i == right) return i;\n let j = i;\n if (comparator(\n load(ptr + ( j << alignof())),\n load(ptr + (++j << alignof()))\n ) > 0) {\n while (\n j < right &&\n (comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >>> 31) // < 0\n ) ++j;\n // reverse\n let k = j;\n while (i < k) {\n let tmp = load(ptr + (i << alignof()));\n store(ptr + (i << alignof()), load(ptr + (k << alignof()))); ++i;\n store(ptr + (k << alignof()), tmp); --k;\n }\n } else {\n while (\n j < right &&\n comparator(\n load(ptr + (j << alignof()), 1 << alignof()),\n load(ptr + (j << alignof()))\n ) >= 0\n ) ++j;\n }\n return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns(\n ptr: usize,\n l: i32,\n m: i32,\n r: i32,\n buffer: usize,\n comparator: Comparator\n): void {\n --m;\n let i: i32, j: i32, t = r + m;\n for (i = m + 1; i > l; --i) {\n store(\n buffer + ((i - 1) << alignof()),\n load(ptr + ((i - 1) << alignof()))\n );\n }\n for (j = m; j < r; ++j) {\n store(\n buffer + ((t - j) << alignof()),\n load(ptr + (j << alignof()), 1 << alignof())\n );\n }\n for (let k = l; k <= r; ++k) {\n let a = load(buffer + (j << alignof()));\n let b = load(buffer + (i << alignof()));\n if (comparator(a, b) < 0) {\n store(ptr + (k << alignof()), a);\n --j;\n } else {\n store(ptr + (k << alignof()), b);\n ++i;\n }\n }\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n abs as builtin_abs,\n ceil as builtin_ceil,\n clz as builtin_clz,\n copysign as builtin_copysign,\n floor as builtin_floor,\n max as builtin_max,\n min as builtin_min,\n sqrt as builtin_sqrt,\n trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data([\n 0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n 0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n 0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n 0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n 0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n 0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3FC5555555555555), // 1.66666666666666657415e-01\n pS1 = reinterpret(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n pS2 = reinterpret(0x3FC9C1550E884455), // 2.01212532134862925881e-01\n pS3 = reinterpret(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n pS4 = reinterpret(0x3F49EFE07501B288), // 7.91534994289814532176e-04\n pS5 = reinterpret(0x3F023DE10DFDF709), // 3.47933107596021167570e-05\n qS1 = reinterpret(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n qS2 = reinterpret(0x40002AE59C598AC8), // 2.02094576023350569471e+00\n qS3 = reinterpret(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n qS4 = reinterpret(0x3FB3B8C5B12E9282); // 7.70381505559019352791e-02\n\n let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2.c\n k = 2043,\n kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n let scale = reinterpret(((0x3FF + k / 2) << 20) << 32);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n // Bits of π/4\n const p0: u64 = 0xC4C6628B80DC1CD1;\n const p1: u64 = 0xC90FDAA22168C234;\n\n const Ox1p_64 = reinterpret(0x3BF0000000000000); // 0x1p-64\n const Ox1p_75 = reinterpret(0x3B40000000000000); // 0x1p-75\n\n let shift = clz(q1);\n\n q1 = q1 << shift | q0 >> (64 - shift);\n q0 <<= shift;\n\n let lo = umuldi(p1, q1);\n let hi = res128_hi;\n\n let ahi = hi >> 11;\n let alo = lo >> 11 | hi << 53;\n let blo = (Ox1p_75 * p0 * q1 + Ox1p_75 * p1 * q0);\n\n rempio2_y0 = (ahi + u64(lo < blo));\n rempio2_y1 = Ox1p_64 * (alo + blo);\n\n return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n u1 = u & 0xFFFFFFFF;\n v1 = v & 0xFFFFFFFF;\n\n u >>= 32;\n v >>= 32;\n\n t = u1 * v1;\n w0 = t & 0xFFFFFFFF;\n t = u * v1 + (t >> 32);\n w1 = t >> 32;\n t = u1 * v + (t & 0xFFFFFFFF);\n\n res128_hi = u * v + w1 + (t >> 32);\n return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n let offset = (magnitude >> 52) - 1045;\n let shift = offset & 63;\n let tblPtr = PIO2_TABLE + ((offset >> 6) << 3);\n let s0: u64, s1: u64, s2: u64;\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let b2 = load(tblPtr, 2 << 3);\n\n // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n if (shift) {\n let rshift = 64 - shift;\n let b3 = load(tblPtr, 3 << 3);\n s0 = b1 >> rshift | b0 << shift;\n s1 = b2 >> rshift | b1 << shift;\n s2 = b3 >> rshift | b2 << shift;\n } else {\n s0 = b0;\n s1 = b1;\n s2 = b2;\n }\n\n let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n // First 128 bits of fractional part of x/(2π)\n let blo = umuldi(s1, significand);\n let bhi = res128_hi;\n\n let ahi = s0 * significand;\n let clo = (s2 >> 32) * (significand >> 32);\n let plo = blo + clo;\n let phi = ahi + bhi + u64(plo < clo);\n\n // r: u128 = p << 2\n let rlo = plo << 2;\n let rhi = phi << 2 | plo >> 62;\n\n // s: i128 = r >> 127\n let slo = rhi >> 63;\n let shi = slo >> 1;\n let q = (phi >> 62) - slo;\n\n let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n let signbit = (u ^ rhi) & 0x8000000000000000;\n let coeff = reinterpret(shifter | signbit);\n\n rempio2_y0 *= coeff;\n rempio2_y1 *= coeff;\n\n return q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n const\n pio2_1 = reinterpret(0x3FF921FB54400000), // 1.57079632673412561417e+00\n pio2_1t = reinterpret(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n pio2_2 = reinterpret(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n pio2_2t = reinterpret(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n pio2_3 = reinterpret(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n pio2_3t = reinterpret(0x397B839A252049C1), // 8.47842766036889956997e-32\n invpio2 = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n let ix = (u >> 32) & 0x7FFFFFFF;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n let q = 1, z: f64, y0: f64, y1: f64;\n if (!sign) {\n z = x - pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z - pio2_1t;\n y1 = (z - y0) - pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z -= pio2_2;\n y0 = z - pio2_2t;\n y1 = (z - y0) - pio2_2t;\n }\n } else { // negative x\n z = x + pio2_1;\n if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n y0 = z + pio2_1t;\n y1 = (z - y0) + pio2_1t;\n } else { // near pi/2, use 33+33+53 bit pi\n z += pio2_2;\n y0 = z + pio2_2t;\n y1 = (z - y0) + pio2_2t;\n }\n q = -1;\n }\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n }\n\n if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n // Use precise Cody Waite scheme\n let q = nearest(x * invpio2);\n let r = x - q * pio2_1;\n let w = q * pio2_1t; // 1st round good to 85 bit\n let j = ix >> 20;\n let y0 = r - w;\n let hi = (reinterpret(y0) >> 32);\n let i = j - ((hi >> 20) & 0x7FF);\n\n if (i > 16) { // 2nd iteration needed, good to 118\n let t = r;\n w = q * pio2_2;\n r = t - w;\n w = q * pio2_2t - ((t - r) - w);\n y0 = r - w;\n hi = (reinterpret(y0) >> 32);\n i = j - ((hi >> 20) & 0x7FF);\n if (i > 49) { // 3rd iteration need, 151 bits acc\n let t = r;\n w = q * pio2_3;\n r = t - w;\n w = q * pio2_3t - ((t - r) - w);\n y0 = r - w;\n }\n }\n let y1 = (r - y0) - w;\n rempio2_y0 = y0;\n rempio2_y1 = y1;\n return q;\n }\n let q = pio2_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n const\n S1 = reinterpret(0xBFC5555555555549), // -1.66666666666666324348e-01\n S2 = reinterpret(0x3F8111111110F8A6), // 8.33333333332248946124e-03\n S3 = reinterpret(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n S4 = reinterpret(0x3EC71DE357B1FE7D), // 2.75573137070700676789e-06\n S5 = reinterpret(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n S6 = reinterpret(0x3DE5D93A5ACFD57C); // 1.58969099521155010221e-10\n\n let z = x * x;\n let w = z * z;\n let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n let v = z * x;\n if (!iy) {\n return x + v * (S1 + z * r);\n } else {\n return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n const\n C1 = reinterpret(0x3FA555555555554C), // 4.16666666666666019037e-02\n C2 = reinterpret(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n C3 = reinterpret(0x3EFA01A019CB1590), // 2.48015872894767294178e-05\n C4 = reinterpret(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n C5 = reinterpret(0x3E21EE9EBDB4B1C4), // 2.08757232129817482790e-09\n C6 = reinterpret(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n let z = x * x;\n let w = z * z;\n let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n let hz = 0.5 * z;\n w = 1.0 - hz;\n return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n const\n T0 = reinterpret(0x3FD5555555555563), // 3.33333333333334091986e-01\n T1 = reinterpret(0x3FC111111110FE7A), // 1.33333333333201242699e-01\n T2 = reinterpret(0x3FABA1BA1BB341FE), // 5.39682539762260521377e-02\n T3 = reinterpret(0x3F9664F48406D637), // 2.18694882948595424599e-02\n T4 = reinterpret(0x3F8226E3E96E8493), // 8.86323982359930005737e-03\n T5 = reinterpret(0x3F6D6D22C9560328), // 3.59207910759131235356e-03\n T6 = reinterpret(0x3F57DBC8FEE08315), // 1.45620945432529025516e-03\n T7 = reinterpret(0x3F4344D8F2F26501), // 5.88041240820264096874e-04\n T8 = reinterpret(0x3F3026F71A8D1068), // 2.46463134818469906812e-04\n T9 = reinterpret(0x3F147E88A03792A6), // 7.81794442939557092300e-05\n T10 = reinterpret(0x3F12B80F32F0A7E9), // 7.14072491382608190305e-05\n T11 = reinterpret(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n T12 = reinterpret(0x3EFB2A7074BF7AD4); // 2.59073051863633712884e-05\n\n const\n one = reinterpret(0x3FF0000000000000), // 1.00000000000000000000e+00\n pio4 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n pio4lo = reinterpret(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n let z: f64, r: f64, v: f64, w: f64, s: f64;\n let hx = (reinterpret(x) >> 32); // high word of x\n let ix = hx & 0x7FFFFFFF; // high word of |x|\n let big = ix >= 0x3FE59428;\n if (big) { // |x| >= 0.6744\n if (hx < 0) { x = -x, y = -y; }\n z = pio4 - x;\n w = pio4lo - y;\n x = z + w;\n y = 0.0;\n }\n z = x * x;\n w = z * z;\n r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n s = z * x;\n r = y + z * (s * (r + v) + y);\n r += T0 * s;\n w = x + r;\n if (big) {\n v = iy;\n return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n }\n if (iy == 1) return w;\n let a: f64, t: f64;\n z = w;\n z = reinterpret(reinterpret(z) & 0xFFFFFFFF00000000);\n v = r - (z - x); // z + v = r + x\n t = a = -one / w; // a = -1.0 / w\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n s = one + t * z;\n return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n if (ASC_SHRINK_LEVEL > 0) {\n const inv32 = 1.0 / 4294967296;\n return (x - 4294967296 * floor(x * inv32));\n } else {\n let result = 0;\n let u = reinterpret(x);\n let e = (u >> 52) & 0x7FF;\n if (e <= 1023 + 30) {\n result = x;\n } else if (e <= 1023 + 30 + 53) {\n let v = (u & ((1 << 52) - 1)) | (1 << 52);\n v = v << e - 1023 - 52 + 32;\n result = (v >> 32);\n result = select(-result, result, u < 0);\n }\n return result;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n h ^= h >> 33; // see: https://github.com/aappleby/smhasher\n h *= 0xFF51AFD7ED558CCD;\n h ^= h >> 33;\n h *= 0xC4CEB9FE1A85EC53;\n h ^= h >> 33;\n return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n h += 0x6D2B79F5;\n h = (h ^ (h >> 15)) * (h | 1);\n h ^= h + (h ^ (h >> 7)) * (h | 61);\n return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n // @ts-ignore: decorator\n @lazy\n export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n // @ts-ignore: decorator\n @lazy\n export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f64 = 0;\n\n // @ts-ignore: decorator\n @inline export function abs(x: f64): f64 {\n return builtin_abs(x);\n }\n\n export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) {\n if (hx < 0) return 2 * pio2_hi + Ox1p_120f;\n return 0;\n }\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n }\n let s: f64, w: f64, z: f64;\n if (hx < 0) {\n // z = (1.0 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = R(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1.0 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n let df = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - df * df) / (s + df);\n w = R(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n const s = reinterpret(0x3FE62E42FEFA39EF);\n let u = reinterpret(x);\n // Prevent propagation for all input values less than 1.0.\n // Note musl lib didn't fix this yet.\n if (u < 0x3FF0000000000000) return (x - x) / 0.0;\n let e = u >> 52 & 0x7FF;\n if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt((x - 1) * (x - 1) + 2 * (x - 1)));\n if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n return log(x) + s;\n }\n\n export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n pio2_lo = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n Ox1p_120f = reinterpret(0x03800000);\n\n let hx = (reinterpret(x) >> 32);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3FF00000) {\n let lx = reinterpret(x);\n if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n return 0 / (x - x);\n }\n if (ix < 0x3FE00000) {\n if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n return x + x * R(x * x);\n }\n // let z = (1.0 - builtin_abs(x)) * 0.5;\n let z = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z);\n let r = R(z);\n if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n else {\n let f = reinterpret(reinterpret(s) & 0xFFFFFFFF00000000);\n let c = (z - f * f) / (s + f);\n x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n }\n return select(-x, x, hx < 0);\n }\n\n export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n const c = reinterpret(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = reinterpret(u & 0x7FFFFFFFFFFFFFFF);\n if (e >= 0x3FF + 26) y = log(y) + c;\n else if (e >= 0x3FF + 1) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3FDDAC670561BB4F), // 4.63647609000806093515e-01\n atanhi1 = reinterpret(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n atanhi2 = reinterpret(0x3FEF730BD281F69B), // 9.82793723247329054082e-01\n atanhi3 = reinterpret(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n atanlo0 = reinterpret(0x3C7A2B7F222F65E2), // 2.26987774529616870924e-17\n atanlo1 = reinterpret(0x3C81A62633145C07), // 3.06161699786838301793e-17\n atanlo2 = reinterpret(0x3C7007887AF0CBBD), // 1.39033110312309984516e-17\n atanlo3 = reinterpret(0x3C91A62633145C07), // 6.12323399573676603587e-17\n aT0 = reinterpret(0x3FD555555555550D), // 3.33333333333329318027e-01\n aT1 = reinterpret(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n aT2 = reinterpret(0x3FC24924920083FF), // 1.42857142725034663711e-01\n aT3 = reinterpret(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n aT4 = reinterpret(0x3FB745CDC54C206E), // 9.09088713343650656196e-02\n aT5 = reinterpret(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n aT6 = reinterpret(0x3FB10D66A0D03D51), // 6.66107313738753120669e-02\n aT7 = reinterpret(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n aT8 = reinterpret(0x3FA97B4B24760DEB), // 4.97687799461593236017e-02\n aT9 = reinterpret(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n aT10 = reinterpret(0x3F90AD3AE322DA11), // 1.62858201153657823623e-02\n Ox1p_120f = reinterpret(0x03800000);\n\n let ix = (reinterpret(x) >> 32);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f64;\n if (ix >= 0x44100000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3FDC0000) {\n if (ix < 0x3E400000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3FF30000) {\n if (ix < 0x3FE60000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x40038000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n let u = reinterpret(x);\n let e = u >> 52 & 0x7FF;\n let y = builtin_abs(x);\n if (e < 0x3FF - 1) {\n if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n } else {\n y = 0.5 * log1p(2 * (y / (1 - y)));\n }\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n const pi_lo = reinterpret(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n if (isNaN(x) || isNaN(y)) return x + y;\n let u = reinterpret(x);\n let ix = (u >> 32);\n let lx = u;\n u = reinterpret(y);\n let iy = (u >> 32);\n let ly = u;\n if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n ix = ix & 0x7FFFFFFF;\n iy = iy & 0x7FFFFFFF;\n if ((iy | ly) == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return PI;\n case 3: return -PI;\n }\n }\n if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n if (ix == 0x7FF00000) {\n if (iy == 0x7FF00000) {\n let t = m & 2 ? 3 * PI / 4 : PI / 4;\n return m & 1 ? -t : t;\n } else {\n let t = m & 2 ? PI : 0;\n return m & 1 ? -t : t;\n }\n }\n let z: f64;\n if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return PI - (z - pi_lo);\n case 3: return (z - pi_lo) - PI;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 715094163,\n B2 = 696219795,\n P0 = reinterpret(0x3FFE03E60F61E692), // 1.87595182427177009643\n P1 = reinterpret(0xBFFE28E092F02420), // -1.88497979543377169875\n P2 = reinterpret(0x3FF9F1604A49D6C2), // 1.621429720105354466140\n P3 = reinterpret(0xBFE844CBBEE751D9), // -0.758397934778766047437\n P4 = reinterpret(0x3FC2B000D4E4EDD7), // 0.145996192886612446982\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = (u >> 32) & 0x7FFFFFFF;\n if (hx >= 0x7FF00000) return x + x;\n if (hx < 0x00100000) {\n u = reinterpret(x * Ox1p54);\n hx = (u >> 32) & 0x7FFFFFFF;\n if (hx == 0) return x;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 1 << 63;\n u |= hx << 32;\n let t = reinterpret(u);\n let r = (t * t) * (t / x);\n t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n t = reinterpret((reinterpret(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n let s = t * t;\n r = x / s;\n r = (r - t) / (2 * t + r);\n t = t + t * r;\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f64): f64 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f64): f64 {\n if (!isFinite(x)) return 32;\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E46A09E) { // |x| < 2**-27 * sqrt(2)\n return 1.0;\n }\n return cos_kern(x, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n return (n + 1) & 2 ? -x : x;\n }\n\n export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n x = reinterpret(u);\n let w = (u >> 32);\n let t: f64;\n if (w < 0x3FE62E42) {\n if (w < 0x3FF00000 - (26 << 20)) return 1;\n t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (w < 0x40862E42) {\n t = exp(x);\n return 0.5 * (t + 1 / t);\n }\n t = expo2(x, 1);\n return t;\n }\n\n export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return exp_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n overflow = reinterpret(0x40862E42FEFA39EF), // 709.782712893383973096\n underflow = reinterpret(0xC0874910D52D3051), // -745.13321910194110842\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let hx = u32(reinterpret(x) >> 32);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x4086232B) {\n if (isNaN(x)) return x;\n if (x > overflow) return x * Ox1p1023;\n if (x < underflow) return 0;\n }\n let hi: f64, lo: f64 = 0;\n let k = 0;\n if (hx > 0x3FD62E42) {\n if (hx >= 0x3FF0A2B2) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x3E300000) {\n hi = x;\n } else return 1.0 + x;\n let xs = x * x;\n // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n let xq = xs * xs;\n let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n let y = 1.0 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f64): f64 {\n return exp2_lut(x);\n }\n\n export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n const\n o_threshold = reinterpret(0x40862E42FEFA39EF), // 7.09782712893383973096e+02\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n invln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n Q1 = reinterpret(0xBFA11111111110F4), // -3.33333333333331316428e-02\n Q2 = reinterpret(0x3F5A01A019FE5585), // 1.58730158725481460165e-03\n Q3 = reinterpret(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n Q4 = reinterpret(0x3ED0CFCA86E65239), // 4.00821782732936239552e-06\n Q5 = reinterpret(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n Ox1p1023 = reinterpret(0x7FE0000000000000); // 0x1p1023\n\n let u = reinterpret(x);\n let hx = u32(u >> 32) & 0x7FFFFFFF;\n let sign = u32(u >> 63);\n let k = 0;\n if (hx >= 0x4043687A) {\n if (isNaN(x)) return x;\n if (sign) return -1;\n if (x > o_threshold) return x * Ox1p1023;\n }\n let c = 0.0, t: f64;\n if (hx > 0x3FD62E42) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3FF0A2B2\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x3C900000) return x;\n let hfx = 0.5 * x;\n let hxs = x * hfx;\n // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n let hxq = hxs * hxs;\n let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x3FF + k) << 52;\n let twopk = reinterpret(u);\n let y: f64;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 1024) y = y * 2.0 * Ox1p1023;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x3FF - k) << 52;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f64): f64 {\n return builtin_floor(x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f64): f64 {\n return x;\n }\n\n export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n const\n SPLIT = reinterpret(0x41A0000000000000) + 1, // 0x1p27 + 1\n Ox1p700 = reinterpret(0x6BB0000000000000),\n Ox1p_700 = reinterpret(0x1430000000000000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFFFFFFFFFF;\n uy &= 0x7FFFFFFFFFFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n let ex = i32(ux >> 52);\n let ey = i32(uy >> 52);\n y = reinterpret(uy);\n if (ey == 0x7FF) return y;\n x = reinterpret(ux);\n if (ex == 0x7FF || uy == 0) return x;\n if (ex - ey > 64) return x + y;\n let z = 1.0;\n if (ex > 0x3FF + 510) {\n z = Ox1p700;\n x *= Ox1p_700;\n y *= Ox1p_700;\n } else if (ey < 0x3FF - 450) {\n z = Ox1p_700;\n x *= Ox1p700;\n y *= Ox1p700;\n }\n let c = x * SPLIT;\n let h = x - c + c;\n let l = x - h;\n let hx = x * x;\n let lx = h * h - hx + (2 * h + l) * l;\n c = y * SPLIT;\n h = y - c + c;\n l = y - h;\n let hy = y * y;\n let ly = h * h - hy + (2 * h + l) * l;\n return z * builtin_sqrt(ly + lx + hy + hx);\n }\n\n export function imul(x: f64, y: f64): f64 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return dtoi32(x) * dtoi32(y);\n }\n\n export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += (hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n ivln10lo = reinterpret(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n log10_2hi = reinterpret(0x3FD34413509F6000), // 3.01029995663611771306e-01\n log10_2lo = reinterpret(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 0x1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln10hi;\n let dk = k;\n let y = dk * log10_2hi;\n let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n return val_lo + w;\n }\n\n export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n ln2_lo = reinterpret(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 1;\n let c = 0.0, f = 0.0;\n if (hx < 0x3FDA827A || bool(hx >> 31)) {\n if (hx >= 0xBFF00000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (hx << 1 < 0x3CA00000 << 1) return x;\n if (hx <= 0xBFD2BEC4) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (hx >= 0x7FF00000) return x;\n if (k) {\n u = reinterpret(1 + x);\n let hu = u32(u >> 32);\n hu += 0x3FF00000 - 0x3FE6A09E;\n k = i32(hu >> 20) - 0x3FF;\n if (k < 54) {\n let uf = reinterpret(u);\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n u = hu << 32 | (u & 0xFFFFFFFF);\n f = reinterpret(u) - 1;\n }\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FF7154765200000), // 1.44269504072144627571e+00\n ivln2lo = reinterpret(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n Lg1 = reinterpret(0x3FE5555555555593), // 6.666666666666735130e-01\n Lg2 = reinterpret(0x3FD999999997FA04), // 3.999999999940941908e-01\n Lg3 = reinterpret(0x3FD2492494229359), // 2.857142874366239149e-01\n Lg4 = reinterpret(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n Lg5 = reinterpret(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n Lg6 = reinterpret(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n Lg7 = reinterpret(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n Ox1p54 = reinterpret(0x4350000000000000); // 1p54\n\n let u = reinterpret(x);\n let hx = u32(u >> 32);\n let k = 0;\n let sign = hx >> 31;\n if (sign || hx < 0x00100000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 54;\n x *= Ox1p54;\n u = reinterpret(x);\n hx = u32(u >> 32);\n } else if (hx >= 0x7FF00000) {\n return x;\n } else if (hx == 0x3FF00000 && u << 32 == 0) {\n return 0;\n }\n hx += 0x3FF00000 - 0x3FE6A09E;\n k += i32(hx >> 20) - 0x3FF;\n hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n u = hx << 32 | (u & 0xFFFFFFFF);\n x = reinterpret(u);\n let f = x - 1.0;\n let hfsq = 0.5 * f * f;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n let r = t2 + t1;\n let hi = f - hfsq;\n u = reinterpret(hi);\n u &= 0xFFFFFFFF00000000;\n hi = reinterpret(u);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let val_hi = hi * ivln2hi;\n let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n let y = k;\n w = y + val_hi;\n val_lo += (y - w) + val_hi;\n val_hi = w;\n return val_lo + val_hi;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f64, value2: f64): f64 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f64, value2: f64): f64 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n return pow_lut(x, y);\n } else {\n const\n dp_h1 = reinterpret(0x3FE2B80340000000), // 5.84962487220764160156e-01\n dp_l1 = reinterpret(0x3E4CFDEB43CFD006), // 1.35003920212974897128e-08\n two53 = reinterpret(0x4340000000000000), // 9007199254740992.0\n huge = reinterpret(0x7E37E43C8800759C), // 1e+300\n tiny = reinterpret(0x01A56E1FC2F8F359), // 1e-300\n L1 = reinterpret(0x3FE3333333333303), // 5.99999999999994648725e-01\n L2 = reinterpret(0x3FDB6DB6DB6FABFF), // 4.28571428578550184252e-01\n L3 = reinterpret(0x3FD55555518F264D), // 3.33333329818377432918e-01\n L4 = reinterpret(0x3FD17460A91D4101), // 2.72728123808534006489e-01\n L5 = reinterpret(0x3FCD864A93C9DB65), // 2.30660745775561754067e-01\n L6 = reinterpret(0x3FCA7E284A454EEF), // 2.06975017800338417784e-01\n P1 = reinterpret(0x3FC555555555553E), // 1.66666666666666019037e-01\n P2 = reinterpret(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n P3 = reinterpret(0x3F11566AAF25DE2C), // 6.61375632143793436117e-05\n P4 = reinterpret(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n P5 = reinterpret(0x3E66376972BEA4D0), // 4.13813679705723846039e-08\n lg2 = reinterpret(0x3FE62E42FEFA39EF), // 6.93147180559945286227e-01\n lg2_h = reinterpret(0x3FE62E4300000000), // 6.93147182464599609375e-01\n lg2_l = reinterpret(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n ovt = reinterpret(0x3C971547652B82FE), // 8.0085662595372944372e-017\n cp = reinterpret(0x3FEEC709DC3A03FD), // 9.61796693925975554329e-01\n cp_h = reinterpret(0x3FEEC709E0000000), // 9.61796700954437255859e-01\n cp_l = reinterpret(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n ivln2 = reinterpret(0x3FF71547652B82FE), // 1.44269504088896338700e+00\n ivln2_h = reinterpret(0x3FF7154760000000), // 1.44269502162933349609e+00\n ivln2_l = reinterpret(0x3E54AE0BF85DDF44), // 1.92596299112661746887e-08\n inv3 = reinterpret(0x3FD5555555555555); // 0.3333333333333333333333\n\n let u_ = reinterpret(x);\n let hx = i32(u_ >> 32);\n let lx = u_;\n u_ = reinterpret(y);\n let hy = i32(u_ >> 32);\n let ly = u_;\n let ix = hx & 0x7FFFFFFF;\n let iy = hy & 0x7FFFFFFF;\n if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n if ( // NaN if either arg is NaN\n ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n ) return x + y;\n let yisint = 0, k: i32;\n if (hx < 0) {\n if (iy >= 0x43400000) yisint = 2;\n else if (iy >= 0x3FF00000) {\n k = (iy >> 20) - 0x3FF;\n let offset = select(52, 20, k > 20) - k;\n let Ly = select(ly, iy, k > 20);\n let jj = Ly >> offset;\n if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n }\n }\n if (ly == 0) {\n if (iy == 0x7FF00000) { // y is +-inf\n if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n }\n if (iy == 0x3FF00000) {\n if (hy >= 0) return x;\n return 1 / x;\n }\n if (hy == 0x40000000) return x * x;\n if (hy == 0x3FE00000) {\n if (hx >= 0) return builtin_sqrt(x);\n }\n }\n let ax = builtin_abs(x), z: f64;\n if (lx == 0) {\n if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n z = ax;\n if (hy < 0) z = 1.0 / z;\n if (hx < 0) {\n if (((ix - 0x3FF00000) | yisint) == 0) {\n let d = z - z;\n z = d / d;\n } else if (yisint == 1) z = -z;\n }\n return z;\n }\n }\n let s = 1.0;\n if (hx < 0) {\n if (yisint == 0) {\n let d = x - x;\n return d / d;\n }\n if (yisint == 1) s = -1.0;\n }\n let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n let j: i32, n: i32;\n if (iy > 0x41E00000) {\n if (iy > 0x43F00000) {\n if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n }\n if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n t = ax - 1.0;\n w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n u = ivln2_h * t;\n v = t * ivln2_l - w * ivln2;\n t1 = u + v;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = v - (t1 - u);\n } else {\n let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n n = 0;\n if (ix < 0x00100000) {\n ax *= two53;\n n -= 53;\n ix = (reinterpret(ax) >> 32);\n }\n n += (ix >> 20) - 0x3FF;\n j = ix & 0x000FFFFF;\n ix = j | 0x3FF00000;\n if (j <= 0x3988E) k = 0;\n else if (j < 0xBB67A) k = 1;\n else {\n k = 0;\n n += 1;\n ix -= 0x00100000;\n }\n ax = reinterpret(reinterpret(ax) & 0xFFFFFFFF | (ix << 32));\n let bp = select(1.5, 1.0, k); // k ? 1.5 : 1.0\n u = ax - bp;\n v = 1.0 / (ax + bp);\n ss = u * v;\n s_h = ss;\n s_h = reinterpret(reinterpret(s_h) & 0xFFFFFFFF00000000);\n t_h = reinterpret(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n t_l = ax - (t_h - bp);\n s_l = v * ((u - s_h * t_h) - s_h * t_l);\n s2 = ss * ss;\n r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n r += s_l * (s_h + ss);\n s2 = s_h * s_h;\n t_h = 3.0 + s2 + r;\n t_h = reinterpret(reinterpret(t_h) & 0xFFFFFFFF00000000);\n t_l = r - ((t_h - 3.0) - s2);\n u = s_h * t_h;\n v = s_l * t_h + t_l * ss;\n p_h = u + v;\n p_h = reinterpret(reinterpret(p_h) & 0xFFFFFFFF00000000);\n p_l = v - (p_h - u);\n let z_h = cp_h * p_h;\n let dp_l = select(dp_l1, 0.0, k);\n let z_l = cp_l * p_h + p_l * cp + dp_l;\n t = n;\n let dp_h = select(dp_h1, 0.0, k);\n t1 = ((z_h + z_l) + dp_h) + t;\n t1 = reinterpret(reinterpret(t1) & 0xFFFFFFFF00000000);\n t2 = z_l - (((t1 - t) - dp_h) - z_h);\n }\n let y1 = y;\n y1 = reinterpret(reinterpret(y1) & 0xFFFFFFFF00000000);\n p_l = (y - y1) * t1 + y * t2;\n p_h = y1 * t1;\n z = p_l + p_h;\n u_ = reinterpret(z);\n j = u32(u_ >> 32);\n let i = u_;\n if (j >= 0x40900000) {\n if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n if (p_l + ovt > z - p_h) return s * huge * huge;\n } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n if (p_l <= z - p_h) return s * tiny * tiny;\n }\n i = j & 0x7FFFFFFF;\n k = (i >> 20) - 0x3FF;\n n = 0;\n if (i > 0x3FE00000) {\n n = j + (0x00100000 >> (k + 1));\n k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n t = 0.0;\n t = reinterpret(u64(n & ~(0x000FFFFF >> k)) << 32);\n n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n if (j < 0) n = -n;\n p_h -= t;\n }\n t = p_l + p_h;\n t = reinterpret(reinterpret(t) & 0xFFFFFFFF00000000);\n u = t * lg2_h;\n v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n z = u + v;\n w = v - (z - u);\n t = z * z;\n t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n r = (z * t1) / (t1 - 2.0) - (w + z * w);\n z = 1.0 - (r - z);\n j = u32(reinterpret(z) >> 32);\n j += n << 20;\n if ((j >> 20) <= 0) z = scalbn(z, n);\n else z = reinterpret(reinterpret(z) & 0xFFFFFFFF | (j << 32));\n return s * z;\n }\n }\n\n export function seedRandom(value: i64): void {\n // Instead zero seed use golden ratio:\n // phi = (1 + sqrt(5)) / 2\n // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n if (value == 0) value = 0x9e3779b97f4a7c15;\n random_state0_64 = murmurHash3(value);\n random_state1_64 = murmurHash3(~random_state0_64);\n random_state0_32 = splitMix32(value);\n random_state1_32 = splitMix32(random_state0_32);\n random_seeded = true;\n }\n\n export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n if (!random_seeded) seedRandom(reinterpret(seed()));\n let s1 = random_state0_64;\n let s0 = random_state1_64;\n random_state0_64 = s0;\n s1 ^= s1 << 23;\n s1 ^= s1 >> 17;\n s1 ^= s0;\n s1 ^= s0 >> 26;\n random_state1_64 = s1;\n let r = (s0 >> 12) | 0x3FF0000000000000;\n return reinterpret(r) - 1;\n }\n\n export function round(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f64(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f64): f64 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f64): bool {\n return bool(reinterpret(x) >>> 63);\n }\n\n export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E500000) { // |x| < 2**-26\n return x;\n }\n return sin_kern(x, 0.0, 0);\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n // argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n\n x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n return n & 2 ? -x : x;\n }\n\n export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n let u = reinterpret(x) & 0x7FFFFFFFFFFFFFFF;\n let a = reinterpret(u);\n let w = u32(u >> 32);\n let h = builtin_copysign(0.5, x);\n if (w < 0x40862E42) {\n let t = expm1(a);\n if (w < 0x3FF00000) {\n if (w < 0x3FF00000 - (26 << 20)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f64): f64 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >>> 31;\n\n ux &= 0x7FFFFFFF;\n\n // |x| ~< pi/4\n if (ux <= 0x3FE921FB) {\n if (ux < 0x3E400000) { // |x| < 2**-27\n return x;\n }\n return tan_kern(x, 0.0, 1);\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7FF00000) return x - x;\n\n let n = rempio2(x, u, sign);\n return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n }\n\n export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFFFFFFFFFF;\n let y = reinterpret(u);\n let w = u32(u >> 32);\n let t: f64;\n if (w > 0x3FE193EA) {\n if (w > 0x40340000) {\n t = 1 - 0 / y;\n } else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (w > 0x3FD058AE) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (w >= 0x00100000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f64): f64 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n const\n Ox1p53 = reinterpret(0x4340000000000000),\n Ox1p1023 = reinterpret(0x7FE0000000000000),\n Ox1p_1022 = reinterpret(0x0010000000000000);\n\n let y = x;\n if (n > 1023) {\n y *= Ox1p1023;\n n -= 1023;\n if (n > 1023) {\n y *= Ox1p1023;\n n = builtin_min(n - 1023, 1023);\n }\n } else if (n < -1022) {\n // make sure final n < -53 to avoid double\n // rounding in the subnormal range\n y *= Ox1p_1022 * Ox1p53;\n n += 1022 - 53;\n if (n < -1022) {\n y *= Ox1p_1022 * Ox1p53;\n n = builtin_max(n + 1022 - 53, -1022);\n }\n }\n return y * reinterpret((0x3FF + n) << 52);\n }\n\n export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n let sx = ux >> 63;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f64(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 12);\n ux <<= 1 - ex;\n } else {\n ux &= u64(-1) >> 12;\n ux |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 52); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 11);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 52;\n ux |= ex << 52;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | (sx << 63));\n }\n\n export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i64(ux >> 52 & 0x7FF);\n let ey = i64(uy >> 52 & 0x7FF);\n if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n if (ux << 1 == 0) return x;\n let uxi = ux;\n if (!ex) {\n ex -= builtin_clz(uxi << 12);\n uxi <<= 1 - ex;\n } else {\n uxi &= u64(-1) >> 12;\n uxi |= 1 << 52;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 12);\n uy <<= 1 - ey;\n } else {\n uy &= u64(-1) >> 12;\n uy |= 1 << 52;\n }\n let q: u32 = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -60;\n else {\n let shift = builtin_clz(uxi << 11);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 52;\n uxi |= ex << 52;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && (q & 1))))) {\n x -= y;\n // ++q;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n let u = reinterpret(x);\n let ux = u32(u >> 32);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3FE921FB) { // |x| ~<= π/4\n if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kern(x, 0, 0);\n sincos_cos = cos_kern(x, 0);\n return;\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2(x, u, sign);\n let y0 = rempio2_y0;\n let y1 = rempio2_y1;\n let s = sin_kern(y0, y1, 1);\n let c = cos_kern(y0, y1);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data([\n 0xA2F9836E4E441529,\n 0xFC2757D1F534DDC0,\n 0xDB6295993C439041,\n 0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n pS0 = reinterpret(0x3E2AAA75), // 1.6666586697e-01f\n pS1 = reinterpret(0xBD2F13BA), // -4.2743422091e-02f\n pS2 = reinterpret(0xBC0DD36B), // -8.6563630030e-03f\n qS1 = reinterpret(0xBF34E5AE); // -7.0662963390e-01f\n\n let p = z * (pS0 + z * (pS1 + z * pS2));\n let q: f32 = 1 + z * qS1;\n return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n const // see: musl/src/math/__expo2f.c\n k = 235,\n kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f\n let scale = reinterpret(u32(0x7F + (k >> 1)) << 23);\n // in directed rounding correct sign before rounding or overflow is important\n return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n let offset = (u >> 23) - 152;\n let shift = u64(offset & 63);\n let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n let b0 = load(tblPtr, 0 << 3);\n let b1 = load(tblPtr, 1 << 3);\n let lo: u64;\n\n if (shift > 32) {\n let b2 = load(tblPtr, 2 << 3);\n lo = b2 >> (96 - shift);\n lo |= b1 << (shift - 32);\n } else {\n lo = b1 >> (32 - shift);\n }\n\n let hi = (b1 >> (64 - shift)) | (b0 << shift);\n let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n let product = mantissa * hi + (mantissa * lo >> 32);\n let r: i64 = product << 2;\n let q = i32((product >> 62) + (r >>> 63));\n rempio2f_y = copysign(coeff, x) * r;\n return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n const\n pi2hi = reinterpret(0x3FF921FB50000000), // 1.57079631090164184570\n pi2lo = reinterpret(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n if (u < 0x4DC90FDB) { // π * 0x1p28\n let q = nearest(x * _2_pi);\n rempio2f_y = x - q * pi2hi - q * pi2lo;\n return q;\n }\n\n let q = pio2f_large_quot(x, u);\n return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n const\n S1 = reinterpret(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n S2 = reinterpret(0x3F811110896EFBB2), // 0x111110896efbb2.0p-59\n S3 = reinterpret(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n S4 = reinterpret(0x3EC6CD878C3B46A7); // 0x16cd878c3b46a7.0p-71\n\n let z = x * x;\n let w = z * z;\n let r = S3 + z * S4;\n let s = z * x;\n return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n const\n C0 = reinterpret(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n C1 = reinterpret(0x3FA55553E1053A42), // 0x155553e1053a42.0p-57\n C2 = reinterpret(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n C3 = reinterpret(0x3EF99342E0EE5069); // 0x199342e0ee5069.0p-68\n\n let z = x * x;\n let w = z * z;\n let r = C2 + z * C3;\n return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n const\n T0 = reinterpret(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n T1 = reinterpret(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n T2 = reinterpret(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n T3 = reinterpret(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n T4 = reinterpret(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n T5 = reinterpret(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n let z = x * x;\n let r = T4 + z * T5;\n let t = T2 + z * T3;\n let w = z * z;\n let s = z * x;\n let u = T0 + z * T1;\n\n r = (x + s * u) + (s * w) * (t + w * r);\n return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n const\n log2e = reinterpret(0x3FF71547652B82FE), // 1.44269504088896340736\n c0 = reinterpret(0x3FD555554FD9CAEF), // 0.33333332822728226129\n c1 = reinterpret(0x3FC999A7A8AF4132), // 0.20000167595436263505\n c2 = reinterpret(0x3FC2438D79437030), // 0.14268654271188685375\n c3 = reinterpret(0x3FBE2F663B001C97); // 0.11791075649681414150\n\n let i = reinterpret(x);\n let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n x = reinterpret(i - (exponent << 52));\n x = (x - 1) / (x + 1);\n let xx = x * x;\n let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n return (2 * log2e) * y + exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n const\n c0 = reinterpret(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n c1 = reinterpret(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n c2 = reinterpret(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n c3 = reinterpret(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n c4 = reinterpret(0x3F55F0896145A89F), // 1.339086685300950937e-3\n c5 = reinterpret(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n if (x < -1022) return 0;\n if (x >= 1024) return Infinity;\n\n let n = nearest(x);\n x -= n;\n let xx = x * x;\n let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n return reinterpret(reinterpret(y) + (n << 52));\n}\n\nexport namespace NativeMathf {\n\n // @ts-ignore: decorator\n @lazy\n export const E = NativeMath.E;\n\n // @ts-ignore: decorator\n @lazy\n export const LN2 = NativeMath.LN2;\n\n // @ts-ignore: decorator\n @lazy\n export const LN10 = NativeMath.LN10;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG2E = NativeMath.LOG2E;\n\n // @ts-ignore: decorator\n @lazy\n export const LOG10E = NativeMath.LOG10E;\n\n // @ts-ignore: decorator\n @lazy\n export const PI = NativeMath.PI;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT1_2 = NativeMath.SQRT1_2;\n\n // @ts-ignore: decorator\n @lazy\n export const SQRT2 = NativeMath.SQRT2;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_sin: f32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export let sincos_cos: f32 = 0;\n\n // @ts-ignore: decorator\n @inline\n export function abs(x: f32): f32 {\n return builtin_abs(x);\n }\n\n export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n const\n pio2_hi = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n pio2_lo = reinterpret(0x33A22168), // 7.5497894159e-08f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let hx = reinterpret(x);\n let ix = hx & 0x7FFFFFFF;\n if (ix >= 0x3F800000) {\n if (ix == 0x3F800000) {\n return select(2 * pio2_hi + Ox1p_120f, 0, hx < 0);\n }\n return 0 / (x - x);\n }\n if (ix < 0x3F000000) {\n if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n }\n let z: f32, w: f32, s: f32;\n if (hx < 0) {\n // z = (1 + x) * 0.5;\n z = 0.5 + x * 0.5;\n s = builtin_sqrt(z);\n w = Rf(z) * s - pio2_lo;\n return 2 * (pio2_hi - (s + w));\n }\n // z = (1 - x) * 0.5;\n z = 0.5 - x * 0.5;\n s = builtin_sqrt(z);\n hx = reinterpret(s);\n let df = reinterpret(hx & 0xFFFFF000);\n let c = (z - df * df) / (s + df);\n w = Rf(z) * s + c;\n return 2 * (df + w);\n }\n\n export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n const s = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x);\n let a = u & 0x7FFFFFFF;\n if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n let xm1 = x - 1;\n return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n }\n if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n return log(2 * x - 1 / (x + builtin_sqrt(x * x - 1)));\n }\n // x >= 0x1p12 or x <= -2 or NaN\n return log(x) + s;\n }\n\n export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n const\n pio2 = reinterpret(0x3FC90FDB), // 1.570796326794896558e+00f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let sx = x;\n let hx = reinterpret(x) & 0x7FFFFFFF;\n if (hx >= 0x3F800000) {\n if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n return 0 / (x - x);\n }\n if (hx < 0x3F000000) {\n if (hx < 0x39800000 && hx >= 0x00800000) return x;\n return x + x * Rf(x * x);\n }\n // let z: f32 = (1 - builtin_abs(x)) * 0.5;\n let z: f32 = 0.5 - builtin_abs(x) * 0.5;\n let s = builtin_sqrt(z); // sic\n x = f32(pio2 - 2 * (s + s * Rf(z)));\n return builtin_copysign(x, sx);\n }\n\n export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n const c = reinterpret(0x3F317218); // 0.693147180559945309417232121458176568f\n let u = reinterpret(x) & 0x7FFFFFFF;\n let y = reinterpret(u);\n if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n else if (u >= 0x3F800000 + (1 << 23)) y = log(2 * y + 1 / (builtin_sqrt(y * y + 1) + y));\n else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt(y * y + 1) + 1));\n return builtin_copysign(y, x);\n }\n\n export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n const\n atanhi0 = reinterpret(0x3EED6338), // 4.6364760399e-01f\n atanhi1 = reinterpret(0x3F490FDA), // 7.8539812565e-01f\n atanhi2 = reinterpret(0x3F7B985E), // 9.8279368877e-01f\n atanhi3 = reinterpret(0x3FC90FDA), // 1.5707962513e+00f\n atanlo0 = reinterpret(0x31AC3769), // 5.0121582440e-09f\n atanlo1 = reinterpret(0x33222168), // 3.7748947079e-08f\n atanlo2 = reinterpret(0x33140FB4), // 3.4473217170e-08f\n atanlo3 = reinterpret(0x33A22168), // 7.5497894159e-08f\n aT0 = reinterpret(0x3EAAAAA9), // 3.3333328366e-01f\n aT1 = reinterpret(0xBE4CCA98), // -1.9999158382e-01f\n aT2 = reinterpret(0x3E11F50D), // 1.4253635705e-01f\n aT3 = reinterpret(0xBDDA1247), // -1.0648017377e-01f\n aT4 = reinterpret(0x3D7CAC25), // 6.1687607318e-02f\n Ox1p_120f = reinterpret(0x03800000); // 0x1p-120f\n\n let ix = reinterpret(x);\n let sx = x;\n ix &= 0x7FFFFFFF;\n let z: f32;\n if (ix >= 0x4C800000) {\n if (isNaN(x)) return x;\n z = atanhi3 + Ox1p_120f;\n return builtin_copysign(z, sx);\n }\n let id: i32;\n if (ix < 0x3EE00000) {\n if (ix < 0x39800000) return x;\n id = -1;\n } else {\n x = builtin_abs(x);\n if (ix < 0x3F980000) {\n if (ix < 0x3F300000) {\n id = 0;\n x = (2.0 * x - 1.0) / (2.0 + x);\n } else {\n id = 1;\n x = (x - 1.0) / (x + 1.0);\n }\n } else {\n if (ix < 0x401C0000) {\n id = 2;\n x = (x - 1.5) / (1.0 + 1.5 * x);\n } else {\n id = 3;\n x = -1.0 / x;\n }\n }\n }\n z = x * x;\n let w = z * z;\n let s1 = z * (aT0 + w * (aT2 + w * aT4));\n let s2 = w * (aT1 + w * aT3);\n let s3 = x * (s1 + s2);\n if (id < 0) return x - s3;\n switch (id) {\n case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n default: unreachable();\n }\n return builtin_copysign(z, sx);\n }\n\n export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n let u = reinterpret(x);\n let y = builtin_abs(x);\n if (u < 0x3F800000 - (1 << 23)) {\n if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n } else y = 0.5 * log1p(2 * (y / (1 - y)));\n return builtin_copysign(y, x);\n }\n\n export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n const\n pi = reinterpret(0x40490FDB), // 3.1415927410e+00f\n pi_lo = reinterpret(0xB3BBBD2E); // -8.7422776573e-08f\n\n if (isNaN(x) || isNaN(y)) return x + y;\n let ix = reinterpret(x);\n let iy = reinterpret(y);\n if (ix == 0x3F800000) return atan(y);\n let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n ix &= 0x7FFFFFFF;\n iy &= 0x7FFFFFFF;\n if (iy == 0) {\n switch (m) {\n case 0:\n case 1: return y;\n case 2: return pi;\n case 3: return -pi;\n }\n }\n if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n if (ix == 0x7F800000) {\n if (iy == 0x7F800000) {\n let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n return m & 1 ? -t : t;\n } else {\n let t: f32 = m & 2 ? pi : 0.0;\n return m & 1 ? -t : t;\n }\n }\n if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n let z: f32;\n if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n else z = atan(builtin_abs(y / x));\n switch (m) {\n case 0: return z;\n case 1: return -z;\n case 2: return pi - (z - pi_lo);\n case 3: return (z - pi_lo) - pi;\n }\n unreachable();\n return 0;\n }\n\n export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n const\n B1 = 709958130,\n B2 = 642849266,\n Ox1p24f = reinterpret(0x4B800000);\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n if (hx >= 0x7F800000) return x + x;\n if (hx < 0x00800000) {\n if (hx == 0) return x;\n u = reinterpret(x * Ox1p24f);\n hx = u & 0x7FFFFFFF;\n hx = hx / 3 + B2;\n } else {\n hx = hx / 3 + B1;\n }\n u &= 0x80000000;\n u |= hx;\n let t = reinterpret(u);\n let r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n r = t * t * t;\n t = t * (x + x + r) / (x + r + r);\n return t;\n }\n\n // @ts-ignore: decorator\n @inline\n export function ceil(x: f32): f32 {\n return builtin_ceil(x);\n }\n\n export function clz32(x: f32): f32 {\n if (!isFinite(x)) return 32;\n return builtin_clz(dtoi32(x));\n }\n\n export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n const\n c1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n c2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n c3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n c4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n // raise inexact if x != 0\n return 1;\n }\n return cos_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux > 0x4016CBE3) { // |x| ~> 3π/4\n return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n } else {\n return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux > 0x40AFEDDF) { // |x| ~> 7π/4\n return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n } else {\n return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n }\n }\n }\n\n // cos(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n return (n + 1) & 2 ? -t : t;\n }\n\n export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n x = reinterpret(u);\n if (u < 0x3F317217) {\n if (u < 0x3F800000 - (12 << 23)) return 1;\n let t = expm1(x);\n // return 1 + t * t / (2 * (1 + t));\n return 1 + t * t / (2 + 2 * t);\n }\n if (u < 0x42B17217) {\n let t = exp(x);\n // return 0.5 * (t + 1 / t);\n return 0.5 * t + 0.5 / t;\n }\n return expo2f(x, 1);\n }\n\n // @ts-ignore: decorator\n @inline\n export function floor(x: f32): f32 {\n return builtin_floor(x);\n }\n\n export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return expf_lut(x);\n } else {\n const\n ln2hi = reinterpret(0x3F317200), // 6.9314575195e-1f\n ln2lo = reinterpret(0x35BFBE8E), // 1.4286067653e-6f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+0f\n P1 = reinterpret(0x3E2AAA8F), // 1.6666625440e-1f\n P2 = reinterpret(0xBB355215), // -2.7667332906e-3f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let hx = reinterpret(x);\n let sign = hx >> 31;\n hx &= 0x7FFFFFFF;\n if (hx >= 0x42AEAC50) {\n if (hx > 0x7F800000) return x; // NaN\n if (hx >= 0x42B17218) {\n if (!sign) return x * Ox1p127f;\n else if (hx >= 0x42CFF1B5) return 0;\n }\n }\n let hi: f32, lo: f32;\n let k: i32;\n if (hx > 0x3EB17218) {\n if (hx > 0x3F851592) {\n k = i32(invln2 * x + builtin_copysign(0.5, x));\n } else {\n k = 1 - (sign << 1);\n }\n hi = x - k * ln2hi;\n lo = k * ln2lo;\n x = hi - lo;\n } else if (hx > 0x39000000) {\n k = 0;\n hi = x;\n lo = 0;\n } else {\n return 1 + x;\n }\n let xx = x * x;\n let c = x - xx * (P1 + xx * P2);\n let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n return k == 0 ? y : scalbn(y, k);\n }\n }\n\n export function exp2(x: f32): f32 {\n return exp2f_lut(x);\n }\n\n export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n invln2 = reinterpret(0x3FB8AA3B), // 1.4426950216e+00f\n Q1 = reinterpret(0xBD088868), // -3.3333212137e-02f\n Q2 = reinterpret(0x3ACF3010), // 1.5807170421e-03f\n Ox1p127f = reinterpret(0x7F000000); // 0x1p+127f\n\n let u = reinterpret(x);\n let hx = u & 0x7FFFFFFF;\n let sign = u >> 31;\n if (hx >= 0x4195B844) {\n if (hx > 0x7F800000) return x;\n if (sign) return -1;\n if (hx > 0x42B17217) { // x > log(FLT_MAX)\n x *= Ox1p127f;\n return x;\n }\n }\n let c: f32 = 0.0, t: f32, k: i32;\n if (hx > 0x3EB17218) {\n k = select(\n 1 - (sign << 1),\n i32(invln2 * x + builtin_copysign(0.5, x)),\n hx < 0x3F851592\n );\n t = k;\n let hi = x - t * ln2_hi;\n let lo = t * ln2_lo;\n x = hi - lo;\n c = (hi - x) - lo;\n } else if (hx < 0x33000000) {\n return x;\n } else k = 0;\n let hfx: f32 = 0.5 * x;\n let hxs: f32 = x * hfx;\n let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n t = 3.0 - r1 * hfx;\n let e = hxs * ((r1 - t) / (6.0 - x * t));\n if (k == 0) return x - (x * e - hxs);\n e = x * (e - c) - c;\n e -= hxs;\n if (k == -1) return 0.5 * (x - e) - 0.5;\n if (k == 1) {\n if (x < -0.25) return -2.0 * (e - (x + 0.5));\n return 1.0 + 2.0 * (x - e);\n }\n u = (0x7F + k) << 23;\n let twopk = reinterpret(u);\n let y: f32;\n if (k < 0 || k > 56) {\n y = x - e + 1.0;\n if (k == 128) y = y * 2.0 * Ox1p127f;\n else y = y * twopk;\n return y - 1.0;\n }\n u = (0x7F - k) << 23;\n y = reinterpret(u);\n if (k < 20) y = (1 - y) - e;\n else y = 1 - (e + y);\n return (x + y) * twopk;\n }\n\n // @ts-ignore: decorator\n @inline\n export function fround(x: f32): f32 {\n return x;\n }\n\n export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n const\n Ox1p90f = reinterpret(0x6C800000),\n Ox1p_90f = reinterpret(0x12800000);\n\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n ux &= 0x7FFFFFFF;\n uy &= 0x7FFFFFFF;\n if (ux < uy) {\n let ut = ux;\n ux = uy;\n uy = ut;\n }\n x = reinterpret(ux);\n y = reinterpret(uy);\n if (uy == 0xFF << 23) return y;\n if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n let z: f32 = 1;\n if (ux >= (0x7F + 60) << 23) {\n z = Ox1p90f;\n x *= Ox1p_90f;\n y *= Ox1p_90f;\n } else if (uy < (0x7F - 60) << 23) {\n z = Ox1p_90f;\n x *= Ox1p90f;\n y *= Ox1p90f;\n }\n return z * builtin_sqrt(f32(x * x + y * y));\n }\n\n // @ts-ignore: decorator\n @inline\n export function imul(x: f32, y: f32): f32 {\n /*\n * Wasm (MVP) and JS have different approaches for double->int conversions.\n *\n * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n * our float-point arguments before actual convertion to integers.\n */\n if (!isFinite(x + y)) return 0;\n return (dtoi32(x) * dtoi32(y));\n }\n\n export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return logf_lut(x);\n } else {\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01f\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f\n Ox1p25f = reinterpret(0x4C000000);\n\n let u = reinterpret(x);\n let k = 0;\n let sign = u >> 31;\n if (sign || u < 0x00800000) {\n if (u << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0;\n k -= 25;\n x *= Ox1p25f;\n u = reinterpret(x);\n } else if (u >= 0x7F800000) {\n return x;\n } else if (u == 0x3F800000) {\n return 0;\n }\n u += 0x3F800000 - 0x3F3504F3;\n k += i32(u >> 23) - 0x7F;\n u = (u & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(u);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n }\n }\n\n export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n const\n ivln10hi = reinterpret(0x3EDE6000), // 4.3432617188e-01f\n ivln10lo = reinterpret(0xB804EAD9), // -3.1689971365e-05f\n log10_2hi = reinterpret(0x3E9A2080), // 3.0102920532e-01f\n log10_2lo = reinterpret(0x355427DB), // 7.9034151668e-07f\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n ux = reinterpret(hi);\n ux &= 0xFFFFF000;\n hi = reinterpret(ux);\n let lo = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n }\n\n export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n const\n ln2_hi = reinterpret(0x3F317180), // 6.9313812256e-01\n ln2_lo = reinterpret(0x3717F7D1), // 9.0580006145e-06\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n let ix = reinterpret(x);\n let c: f32 = 0;\n let f: f32 = 0;\n let k = 1;\n if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n if (ix >= 0xBF800000) {\n if (x == -1) return x / 0.0;\n return (x - x) / 0.0;\n }\n if (ix << 1 < 0x33800000 << 1) return x;\n if (ix <= 0xBE95F619) {\n k = 0;\n c = 0;\n f = x;\n }\n } else if (ix >= 0x7F800000) return x;\n if (k) {\n let uf: f32 = 1 + x;\n let iu = reinterpret(uf);\n iu += 0x3F800000 - 0x3F3504F3;\n k = i32(iu >> 23) - 0x7F;\n if (k < 25) {\n c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n c /= uf;\n } else c = 0;\n iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n f = reinterpret(iu) - 1;\n }\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let dk = k;\n return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n }\n\n export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n if (ASC_SHRINK_LEVEL < 1) {\n return log2f_lut(x);\n } else {\n const\n ivln2hi = reinterpret(0x3FB8B000), // 1.4428710938e+00f\n ivln2lo = reinterpret(0xB9389AD4), // -1.7605285393e-04\n Lg1 = reinterpret(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n Lg2 = reinterpret(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n Lg3 = reinterpret(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n Lg4 = reinterpret(0x3E789E26), // 0xf89e26.0p-26f, 0.24279078841f\n Ox1p25f = reinterpret(0x4C000000); // 0x1p25f\n\n let ux = reinterpret(x);\n let k = 0;\n let sign = ux >> 31;\n if (sign || ux < 0x00800000) {\n if (ux << 1 == 0) return -1 / (x * x);\n if (sign) return (x - x) / 0.0;\n k -= 25;\n x *= Ox1p25f;\n ux = reinterpret(x);\n } else if (ux >= 0x7F800000) {\n return x;\n } else if (ux == 0x3F800000) {\n return 0;\n }\n ux += 0x3F800000 - 0x3F3504F3;\n k += i32(ux >> 23) - 0x7F;\n ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n x = reinterpret(ux);\n let f = x - 1.0;\n let s = f / (2.0 + f);\n let z = s * s;\n let w = z * z;\n let t1 = w * (Lg2 + w * Lg4);\n let t2 = z * (Lg1 + w * Lg3);\n let r = t2 + t1;\n let hfsq: f32 = 0.5 * f * f;\n let hi = f - hfsq;\n let u = reinterpret(hi);\n u &= 0xFFFFF000;\n hi = reinterpret(u);\n let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n let dk = k;\n return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function max(value1: f32, value2: f32): f32 {\n return builtin_max(value1, value2);\n }\n\n // @ts-ignore: decorator\n @inline\n export function min(value1: f32, value2: f32): f32 {\n return builtin_min(value1, value2);\n }\n\n export function pow(x: f32, y: f32): f32 {\n // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n if (builtin_abs(y) <= 2) {\n if (y == 2.0) return x * x;\n if (y == 0.5) {\n return select(\n builtin_abs(builtin_sqrt(x)),\n Infinity,\n x != -Infinity\n );\n }\n if (y == -1.0) return 1 / x;\n if (y == 1.0) return x;\n if (y == 0.0) return 1.0;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n // see: musl/src/math/powf.c\n return powf_lut(x, y);\n } else {\n // based on: jdh8/metallic/src/math/float/powf.c\n if (y == 0) return 1;\n // @ts-ignore: cast\n if (isNaN(x) | isNaN(y)) {\n return NaN;\n }\n let sign: u32 = 0;\n let uy = reinterpret(y);\n let ux = reinterpret(x);\n let sx = ux >> 31;\n ux &= 0x7FFFFFFF;\n if (sx && nearest(y) == y) {\n x = -x;\n sx = 0;\n sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n }\n let m: u32;\n if (ux == 0x3F800000) { // x == 1\n m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n } else if (ux == 0) {\n m = uy < 0 ? 0x7F800000 : 0;\n } else if (ux == 0x7F800000) {\n m = uy < 0 ? 0 : 0x7F800000;\n } else if (sx) {\n m = 0x7FC00000;\n } else {\n m = reinterpret(exp2f(y * log2f(x)));\n }\n return reinterpret(m | sign);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function seedRandom(value: i64): void {\n NativeMath.seedRandom(value);\n }\n\n // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n export function random(): f32 {\n if (!random_seeded) seedRandom(reinterpret(seed()));\n\n let s0 = random_state0_32;\n let s1 = random_state1_32;\n let r = rotl(s0 * 0x9E3779BB, 5) * 5;\n\n s1 ^= s0;\n random_state0_32 = rotl(s0, 26) ^ s1 ^ (s1 << 9);\n random_state1_32 = rotl(s1, 13);\n\n return reinterpret((r >> 9) | (127 << 23)) - 1.0;\n }\n\n export function round(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return builtin_ceil(x) - f32(builtin_ceil(x) - 0.5 > x);\n } else {\n let roundUp = builtin_ceil(x);\n return select(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n }\n }\n\n export function sign(x: f32): f32 {\n if (ASC_SHRINK_LEVEL > 0) {\n return select(builtin_copysign(1, x), x, builtin_abs(x) > 0);\n } else {\n return select(1, select(-1, x, x < 0), x > 0);\n }\n }\n\n // @ts-ignore: decorator\n @inline\n export function signbit(x: f32): bool {\n return (reinterpret(x) >>> 31);\n }\n\n export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // M_PI_2 * 1\n s2pio2 = reinterpret(0x400921FB54442D18), // M_PI_2 * 2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // M_PI_2 * 3\n s4pio2 = reinterpret(0x401921FB54442D18); // M_PI_2 * 4\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return sin_kernf(x);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n }\n return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n }\n\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n }\n return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n }\n }\n\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n\n let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n return n & 2 ? -t : t;\n }\n\n export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n let u = reinterpret(x) & 0x7FFFFFFF;\n let a = reinterpret(u);\n let h = builtin_copysign(0.5, x);\n if (u < 0x42B17217) {\n let t = expm1(a);\n if (u < 0x3F800000) {\n if (u < 0x3F800000 - (12 << 23)) return x;\n return h * (2 * t - t * t / (t + 1));\n }\n return h * (t + t / (t + 1));\n }\n return expo2f(a, 2 * h);\n }\n\n // @ts-ignore: decorator\n @inline\n export function sqrt(x: f32): f32 {\n return builtin_sqrt(x);\n }\n\n export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n const\n t1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n t2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n t3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n t4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n return x;\n }\n return tan_kernf(x, 0);\n }\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n } else {\n return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n }\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n } else {\n return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n }\n }\n }\n\n // tan(Inf or NaN) is NaN\n if (ux >= 0x7F800000) return x - x;\n\n // argument reduction\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n return tan_kernf(y, n & 1);\n }\n\n export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n let u = reinterpret(x);\n u &= 0x7FFFFFFF;\n let y = reinterpret(u);\n let t: f32;\n if (u > 0x3F0C9F54) {\n if (u > 0x41200000) t = 1 + 0 / y;\n else {\n t = expm1(2 * y);\n t = 1 - 2 / (t + 2);\n }\n } else if (u > 0x3E82C578) {\n t = expm1(2 * y);\n t = t / (t + 2);\n } else if (u >= 0x00800000) {\n t = expm1(-2 * y);\n t = -t / (t + 2);\n } else t = y;\n return builtin_copysign(t, x);\n }\n\n // @ts-ignore: decorator\n @inline\n export function trunc(x: f32): f32 {\n return builtin_trunc(x);\n }\n\n export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n const\n Ox1p24f = reinterpret(0x4B800000),\n Ox1p127f = reinterpret(0x7F000000),\n Ox1p_126f = reinterpret(0x00800000);\n\n let y = x;\n if (n > 127) {\n y *= Ox1p127f;\n n -= 127;\n if (n > 127) {\n y *= Ox1p127f;\n n = builtin_min(n - 127, 127);\n }\n } else if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n += 126 - 24;\n if (n < -126) {\n y *= Ox1p_126f * Ox1p24f;\n n = builtin_max(n + 126 - 24, -126);\n }\n }\n return y * reinterpret((0x7F + n) << 23);\n }\n\n export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n if (builtin_abs(y) == 1.0) {\n // x % 1, x % -1 ==> sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n // TODO: move this rule to compiler's optimization pass.\n // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n return builtin_copysign(x - builtin_trunc(x), x);\n }\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let sm = ux & 0x80000000;\n let uy1 = uy << 1;\n if (uy1 == 0 || ex == 0xFF || isNaN(y)) {\n let m = x * y;\n return m / m;\n }\n let ux1 = ux << 1;\n if (ux1 <= uy1) {\n return x * f32(ux1 != uy1);\n }\n if (!ex) {\n ex -= builtin_clz(ux << 9);\n ux <<= 1 - ex;\n } else {\n ux &= -1 >> 9;\n ux |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n while (ex > ey) {\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n ux <<= 1;\n --ex;\n }\n if (ux >= uy) {\n if (ux == uy) return 0 * x;\n ux -= uy;\n }\n // for (; !(ux >> 23); ux <<= 1) --ex;\n let shift = builtin_clz(ux << 8);\n ex -= shift;\n ux <<= shift;\n if (ex > 0) {\n ux -= 1 << 23;\n ux |= ex << 23;\n } else {\n ux >>= -ex + 1;\n }\n return reinterpret(ux | sm);\n }\n\n export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n let ux = reinterpret(x);\n let uy = reinterpret(y);\n let ex = i32(ux >> 23 & 0xFF);\n let ey = i32(uy >> 23 & 0xFF);\n let uxi = ux;\n if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n if (ux << 1 == 0) return x;\n if (!ex) {\n ex -= builtin_clz(uxi << 9);\n uxi <<= 1 - ex;\n } else {\n uxi &= u32(-1) >> 9;\n uxi |= 1 << 23;\n }\n if (!ey) {\n ey -= builtin_clz(uy << 9);\n uy <<= 1 - ey;\n } else {\n uy &= u32(-1) >> 9;\n uy |= 1 << 23;\n }\n let q = 0;\n do {\n if (ex < ey) {\n if (ex + 1 == ey) break; // goto end\n return x;\n }\n while (ex > ey) {\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n uxi <<= 1;\n q <<= 1;\n --ex;\n }\n if (uxi >= uy) {\n uxi -= uy;\n ++q;\n }\n if (uxi == 0) ex = -30;\n else {\n let shift = builtin_clz(uxi << 8);\n ex -= shift;\n uxi <<= shift;\n }\n break;\n } while (false);\n // end:\n if (ex > 0) {\n uxi -= 1 << 23;\n uxi |= ex << 23;\n } else {\n uxi >>= -ex + 1;\n }\n x = reinterpret(uxi);\n y = builtin_abs(y);\n let x2 = x + x;\n if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && bool(q & 1))))) {\n x -= y;\n // q++;\n }\n return ux < 0 ? -x : x;\n }\n\n export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n const\n s1pio2 = reinterpret(0x3FF921FB54442D18), // 1 * M_PI_2\n s2pio2 = reinterpret(0x400921FB54442D18), // 2 * M_PI_2\n s3pio2 = reinterpret(0x4012D97C7F3321D2), // 3 * M_PI_2\n s4pio2 = reinterpret(0x401921FB54442D18); // 4 * M_PI_2\n\n let ux = reinterpret(x);\n let sign = ux >> 31;\n ux &= 0x7FFFFFFF;\n\n if (ux <= 0x3F490FDA) { // |x| ~<= π/4\n if (ux < 0x39800000) { // |x| < 2**-12\n sincos_sin = x;\n sincos_cos = 1;\n return;\n }\n sincos_sin = sin_kernf(x);\n sincos_cos = cos_kernf(x);\n return;\n }\n if (ASC_SHRINK_LEVEL < 1) {\n if (ux <= 0x407B53D1) { // |x| ~<= 5π/4\n if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n if (sign) {\n sincos_sin = -cos_kernf(x + s1pio2);\n sincos_cos = sin_kernf(x + s1pio2);\n } else {\n sincos_sin = cos_kernf(s1pio2 - x);\n sincos_cos = sin_kernf(s1pio2 - x);\n }\n return;\n }\n // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n return;\n }\n if (ux <= 0x40E231D5) { // |x| ~<= 9π/4\n if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n if (sign) {\n sincos_sin = cos_kernf(x + s3pio2);\n sincos_cos = -sin_kernf(x + s3pio2);\n } else {\n sincos_sin = -cos_kernf(x - s3pio2);\n sincos_cos = sin_kernf(x - s3pio2);\n }\n return;\n }\n sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n return;\n }\n }\n // sin(Inf or NaN) is NaN\n if (ux >= 0x7F800000) {\n let xx = x - x;\n sincos_sin = xx;\n sincos_cos = xx;\n return;\n }\n // general argument reduction needed\n let n = rempio2f(x, ux, sign);\n let y = rempio2f_y;\n let s = sin_kernf(y);\n let c = cos_kernf(y);\n let sin = s, cos = c;\n if (n & 1) {\n sin = c;\n cos = -s;\n }\n if (n & 2) {\n sin = -sin;\n cos = -cos;\n }\n sincos_sin = sin;\n sincos_cos = cos;\n }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n let out = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 32);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i32(e == 0) | i32(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 32) {\n let log = 32 - clz(e);\n // 32 = 2 ^ 5, so need only five cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n let out: i64 = 1;\n if (ASC_SHRINK_LEVEL < 1) {\n if (x == 2) {\n return select(1 << e, 0, e < 64);\n }\n if (e <= 0) {\n if (x == -1) return select(-1, 1, e & 1);\n return i64(e == 0) | i64(x == 1);\n }\n else if (e == 1) return x;\n else if (e == 2) return x * x;\n else if (e < 64) {\n let log = 64 - clz(e);\n // 64 = 2 ^ 6, so need only six cases.\n // But some extra cases needs for properly overflowing\n switch (log) {\n case 6: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 5: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 4: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 3: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 2: {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n case 1: {\n if (e & 1) out *= x;\n }\n }\n return out;\n }\n }\n while (e) {\n if (e & 1) out *= x;\n e >>>= 1;\n x *= x;\n }\n return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n case 1: return x;\n case 2: return x * x;\n case 3: return x * x * x;\n case 4: return (b = x * x) * b;\n case 5: return (b = x * x) * b * x;\n case 6: return (b = x * x) * b * b;\n case 7: return (b = x * x) * b * b * x;\n case 8: return (d = (b = x * x) * b) * d;\n case 9: return (c = x * x * x) * c * c;\n case 10: return (d = (b = x * x) * b) * d * b;\n case 11: return (d = (b = x * x) * b) * d * b * x;\n case 12: return (d = (b = x * x) * b) * d * d;\n case 13: return (d = (b = x * x) * b) * d * d * x;\n case 14: return (d = (b = x * x) * b) * d * d * b;\n case 15: return (k = (b = x * x) * b * x) * k * k;\n case 16: return (h = (d = (b = x * x) * b) * d) * h;\n case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n case 32:\n ...\n case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked(expr: T): T;\n\nexport namespace inline {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function always(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate(...args: auto[]): T;\n\nexport namespace atomic {\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: T, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n // @ts-ignore: decorator\n @builtin\n export declare function notify(ptr: usize, count: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n OK = 0,\n NOT_EQUAL = 1,\n TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i8 = -128;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i8 = 127;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i16 = -32768;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i16 = 32767;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i32 = -2147483648;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i32 = 2147483647;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i32, shift: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i32, right:i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i32, right: i32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u32, right: u32): u32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f32(value: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: i64 = -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: i64 = 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function clz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ctz(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_s(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div_u(left: i64, right:i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(value: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotl(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rotr(value: i64, shift: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: i64, right:i64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_s(left: i64, right: i64): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function rem_u(left: u64, right: u64): u64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_f64(value: f64): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n export namespace atomic {\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n export namespace rmw8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw32 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n\n export namespace rmw {\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n }\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: isize = sizeof() == sizeof()\n ? -2147483648\n : -9223372036854775808;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: isize = sizeof() == sizeof()\n ? 2147483647\n : 9223372036854775807;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u8 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u8 = 255;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u16 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u16 = 65535;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u32 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u32 = 4294967295;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: u64 = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: u64 = 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: usize = 0;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: usize = sizeof() == sizeof()\n ? 4294967295\n : 18446744073709551615;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE: bool = false;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE: bool = true;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): bool {\n return strtob(value);\n }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x34000000); // 0x1p-23f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f32 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f32 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f32 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f32, y: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i32(value: i32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f32): f32;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f32, right: f32): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f32, right: f32): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n // @ts-ignore: decorator\n @lazy\n export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022\n\n // @ts-ignore: decorator\n @lazy\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n\n // @ts-ignore: decorator\n @lazy\n export const POSITIVE_INFINITY: f64 = Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n // @ts-ignore: decorator\n @lazy\n export const NaN: f64 = 0.0 / 0.0;\n\n // @ts-ignore: decorator\n @inline\n export function parse(value: string): f64 {\n return strtod(value);\n }\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function copysign(x: f64, y: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function reinterpret_i64(value: i64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(value: f64): f64;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(value: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(left: f64, right: f64): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(left: f64, right: f64): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): T;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: T): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_ext(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_zero(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store_lane(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load_splat(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n // @ts-ignore: decorator\n @unsafe @builtin\n export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function and(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function or(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function xor(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function andnot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function not(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function any_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot(a: v128, b: v128): v128; // i16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr(a: v128, b: v128): v128; // u8, u16 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128; // f32, f64 only\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_add(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function popcnt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function swizzle(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function avgr_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub_sat_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(\n a: v128, b: v128,\n l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n ): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): i64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shl(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_s(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shr_u(a: v128, b: i32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function all_true(a: v128): bool;\n\n // @ts-ignore: decorator\n @builtin\n export declare function bitmask(a: v128): i32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extend_high_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f32;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function demote_f64x2_zero(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n // @ts-ignore: decorator\n @builtin\n export declare function splat(x: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function extract_lane(x: v128, idx: u8): f64;\n\n // @ts-ignore: decorator\n @builtin\n export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function add(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sub(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function mul(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function div(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function neg(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function max(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmin(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function pmax(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function abs(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function sqrt(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ceil(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function floor(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function trunc(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function nearest(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function eq(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ne(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function lt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function le(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function gt(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function ge(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_s(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function convert_low_i32x4_u(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function promote_low_f32x4(a: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_min(a: v128, b: v128): v128;\n\n // @ts-ignore: decorator\n @builtin\n export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n // @ts-ignore: decorator\n @builtin\n static new(value: i32): i31ref { return changetype(unreachable()); }\n\n // @ts-ignore: decorator\n @builtin\n static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n message?: string | null,\n fileName?: string | null,\n lineNumber?: u32,\n columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n message: string,\n n?: i32,\n a0?: f64,\n a1?: f64,\n a2?: f64,\n a3?: f64,\n a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","type Register = u64;\n\nexport const NO_OF_REGISTERS = 13;\nexport const REG_SIZE_BYTES = 8;\n\nexport type Registers = StaticArray;\n\nexport function newRegisters(): Registers {\n return new StaticArray(NO_OF_REGISTERS);\n}\n","export type PageIndex = u32;\nexport type ArenaId = u32;\n\n/** `Z_P`: https://graypaper.fluffylabs.dev/#/ab2cdbd/44d20044d200?v=0.7.2 */\nexport const PAGE_SIZE: u32 = 2 ** 12; // 4_096\nexport const PAGE_SIZE_SHIFT: u32 = 12;\n\n/** `Z_Z`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const SEGMENT_SIZE: u32 = 2 ** 16; //65_536\nexport const SEGMENT_SIZE_SHIFT: u32 = 16;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/254401254a01?v=0.7.2 */\nexport const RESERVED_MEMORY: u32 = 2 ** 16;\nexport const RESERVED_PAGES: u32 = RESERVED_MEMORY / PAGE_SIZE; // 16\n\n/** Amount of memory to allocate eagerly */\nexport const ALLOCATE_EAGERLY: u32 = 2 ** 29; // 512MB\n\nexport enum Access {\n None = 0,\n Read = 1,\n Write = 2,\n}\n\nexport class Page {\n constructor(\n public readonly access: Access,\n public readonly raw: RawPage,\n ) {}\n\n can(access: Access): boolean {\n return this.access === Access.Write || this.access === access;\n }\n}\n\nexport class RawPage {\n constructor(\n public readonly id: ArenaId,\n public page: Uint8Array | null,\n ) {}\n\n get data(): Uint8Array {\n if (this.page === null) {\n this.page = new Uint8Array(PAGE_SIZE).fill(0);\n }\n return this.page as Uint8Array;\n }\n}\n\nexport class Arena {\n private free: RawPage[];\n private readonly arenaBytes: u32;\n private extraPageIndex: ArenaId;\n\n constructor(pageCount: u32) {\n this.arenaBytes = PAGE_SIZE * pageCount;\n this.free = [];\n this.extraPageIndex = pageCount;\n const data = new ArrayBuffer(this.arenaBytes);\n for (let i = 0; i < pageCount; i++) {\n this.free.unshift(new RawPage(i, Uint8Array.wrap(data, i * PAGE_SIZE, PAGE_SIZE)));\n }\n }\n\n acquire(): RawPage {\n if (this.free.length > 0) {\n return this.free.pop();\n }\n // no pages!\n const allocatedMemory = this.extraPageIndex * PAGE_SIZE;\n // print warning only once\n if (allocatedMemory === this.arenaBytes) {\n console.log(\"Warning: Run out of pages! Allocating.\");\n }\n\n // actually allocate for some time, but later do it lazily\n const data = allocatedMemory < ALLOCATE_EAGERLY ? new Uint8Array(PAGE_SIZE) : null;\n this.extraPageIndex += 1;\n return new RawPage(this.extraPageIndex, data);\n }\n\n release(page: RawPage): void {\n this.free.push(page);\n }\n}\n","import { u8SignExtend, u16SignExtend, u32SignExtend } from \"./instructions/utils\";\nimport {\n Access,\n Arena,\n PAGE_SIZE,\n PAGE_SIZE_SHIFT,\n Page,\n PageIndex,\n RawPage,\n RESERVED_MEMORY,\n RESERVED_PAGES,\n} from \"./memory-page\";\n\n// @unmanaged\nexport class MaybePageFault {\n isFault: boolean = false;\n isAccess: boolean = false;\n fault: u32 = 0;\n}\n\n// @unmanaged\nexport class Result {\n ok: u64 = 0;\n fault: MaybePageFault = new MaybePageFault();\n}\n\nconst NO_PAGE_FAULT = new MaybePageFault();\n\nclass Chunks {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly first: Uint8Array = EMPTY_UINT8ARRAY,\n public readonly second: Uint8Array = EMPTY_UINT8ARRAY,\n ) {}\n}\n\nclass ChunkBytes {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly bytes: StaticArray = new StaticArray(0),\n ) {}\n}\n\nclass PageData {\n constructor(\n public readonly fault: MaybePageFault,\n public readonly page: Page,\n public readonly relativeAddress: u32,\n ) {}\n}\n\nconst MEMORY_SIZE = 0x1_0000_0000;\n\nconst EMPTY_UINT8ARRAY = new Uint8Array(0);\nconst EMPTY_PAGE = new Page(Access.None, new RawPage(-1, null));\n\nexport class MemoryBuilder {\n private readonly pages: Map = new Map();\n private arena: Arena = new Arena(128);\n\n /** Allocates memory pages with given `access`, for given `address` and initialize with `zeroes` */\n setEmpty(access: Access, address: u32, len: u32): MemoryBuilder {\n const endAddress = address + len;\n for (let currentAddress = address; currentAddress < endAddress; currentAddress += PAGE_SIZE) {\n this.getOrCreatePageForAddress(access, currentAddress);\n }\n return this;\n }\n\n /** Allocates memory pages with given `access`, for given `address` and writes there `data` */\n setData(access: Access, address: u32, data: Uint8Array): MemoryBuilder {\n let currentAddress = address;\n let currentData = data;\n while (currentData.length > 0) {\n const page = this.getOrCreatePageForAddress(access, currentAddress);\n\n const relAddress = currentAddress % PAGE_SIZE;\n const spaceInPage = PAGE_SIZE - relAddress;\n const end = u32(currentData.length) < spaceInPage ? currentData.length : spaceInPage;\n page.raw.data.set(currentData.subarray(0, end), relAddress);\n\n // move to the next address to write\n currentAddress = currentAddress + end;\n currentData = currentData.subarray(end);\n }\n return this;\n }\n\n /** Returns memory page for given address (creates if not exists) */\n getOrCreatePageForAddress(access: Access, address: u32): Page {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n if (pageIdx < RESERVED_PAGES) {\n throw new Error(`Attempting to allocate reserved page: ${pageIdx}`);\n }\n\n if (!this.pages.has(pageIdx)) {\n const page = this.arena.acquire();\n this.pages.set(pageIdx, new Page(access, page));\n }\n\n return this.pages.get(pageIdx);\n }\n\n build(sbrkAddress: u32 = RESERVED_MEMORY): Memory {\n return new Memory(this.arena, this.pages, sbrkAddress);\n }\n}\n\nexport class Memory {\n private lastAllocatedPage: i32;\n\n constructor(\n private readonly arena: Arena,\n public readonly pages: Map = new Map(),\n private sbrkAddress: u32 = 0,\n ) {\n const sbrkPage = u32(sbrkAddress >> PAGE_SIZE_SHIFT);\n if (sbrkPage < RESERVED_PAGES) {\n throw new Error(\"sbrk within reserved memory is not allowed!\");\n }\n this.lastAllocatedPage = pages.has(sbrkPage) ? sbrkPage : sbrkPage - 1;\n }\n\n pageDump(index: PageIndex): Uint8Array | null {\n if (!this.pages.has(index)) {\n return null;\n }\n return this.pages.get(index).raw.data;\n }\n\n free(): void {\n const pages = this.pages.values();\n for (let i = 0; i < pages.length; i++) {\n this.arena.release(pages[i].raw);\n }\n this.pages.clear();\n }\n\n sbrk(amount: u32): Result {\n const freeMemoryStart = new Result();\n freeMemoryStart.ok = this.sbrkAddress;\n if (amount === 0) {\n return freeMemoryStart;\n }\n\n const newSbrk = i64(this.sbrkAddress) + amount;\n if (newSbrk >= MEMORY_SIZE) {\n freeMemoryStart.fault.isFault = true;\n return freeMemoryStart;\n }\n this.sbrkAddress = u32(newSbrk);\n\n const pageIdx = i32((newSbrk - 1) >> PAGE_SIZE_SHIFT);\n if (pageIdx === this.lastAllocatedPage) {\n return freeMemoryStart;\n }\n\n for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {\n const page = this.arena.acquire();\n this.pages.set(i, new Page(Access.Write, page));\n }\n\n this.lastAllocatedPage = pageIdx;\n return freeMemoryStart;\n }\n\n getU8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n }\n return r;\n }\n\n getU16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n }\n return r;\n }\n\n getU32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n }\n return r;\n }\n\n getU64(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 8);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = res.bytes[0];\n r.ok |= (res.bytes[1]) << 8;\n r.ok |= (res.bytes[2]) << 16;\n r.ok |= (res.bytes[3]) << 24;\n r.ok |= u64(res.bytes[4]) << 32;\n r.ok |= u64(res.bytes[5]) << 40;\n r.ok |= u64(res.bytes[6]) << 48;\n r.ok |= u64(res.bytes[7]) << 56;\n }\n return r;\n }\n\n getI8(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 1);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n r.ok = u8SignExtend(res.bytes[0]);\n }\n return r;\n }\n\n getI16(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 2);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u16(res.bytes[0]);\n l |= u16(res.bytes[1]) << 8;\n r.ok = u16SignExtend(l);\n }\n return r;\n }\n\n getI32(address: u32): Result {\n const res = this.getBytes(Access.Read, address, 4);\n const r = new Result();\n r.fault = res.fault;\n if (!res.fault.isFault) {\n let l = u32(res.bytes[0]);\n l |= u32(res.bytes[1]) << 8;\n l |= u32(res.bytes[2]) << 16;\n l |= u32(res.bytes[3]) << 24;\n r.ok = u32SignExtend(l);\n }\n return r;\n }\n\n setU8(address: u32, value: u8): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 1);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value;\n return res.fault;\n }\n\n setU16(address: u32, value: u16): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 2);\n if (res.fault.isFault) {\n return res.fault;\n }\n res.first[0] = value & 0xff;\n if (res.first.length > 1) {\n res.first[1] = value >> 8;\n } else {\n res.second[0] = value >> 8;\n }\n return res.fault;\n }\n\n setU32(address: u32, value: u32): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 4);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = v & 0xff;\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = v & 0xff;\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n setU64(address: u32, value: u64): MaybePageFault {\n const res = this.getChunks(Access.Write, address, 8);\n if (res.fault.isFault) {\n return res.fault;\n }\n\n let v = value;\n const len = res.first.length;\n\n for (let i = 0; i < len; i++) {\n res.first[i] = u8(v);\n v = v >> 8;\n }\n\n for (let i = 0; i < res.second.length; i++) {\n res.second[i] = u8(v);\n v = v >> 8;\n }\n\n return res.fault;\n }\n\n bytesRead(address: u32, destination: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let destinationIndex = 0;\n\n while (destinationIndex < destination.length) {\n const bytesLeft = destination.length - destinationIndex;\n const pageData = this.getPage(Access.Read, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToRead = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const source = pageData.page.raw.data.subarray(relAddress, relAddress + bytesToRead);\n destination.set(source, destinationIndex);\n // move the pointers\n destinationIndex += bytesToRead;\n nextAddress += bytesToRead;\n }\n\n return NO_PAGE_FAULT;\n }\n\n bytesWrite(address: u32, source: Uint8Array): MaybePageFault {\n let nextAddress = address;\n let sourceIndex = 0;\n\n while (sourceIndex < source.length) {\n const bytesLeft = source.length - sourceIndex;\n const pageData = this.getPage(Access.Write, nextAddress);\n if (pageData.fault.isFault) {\n return pageData.fault;\n }\n const relAddress = pageData.relativeAddress;\n const bytesToWrite = relAddress + bytesLeft < PAGE_SIZE ? bytesLeft : PAGE_SIZE - pageData.relativeAddress;\n // actually copy the bytes\n const sourceData = source.subarray(sourceIndex, sourceIndex + bytesToWrite);\n pageData.page.raw.data.set(sourceData, relAddress);\n // move the pointers\n sourceIndex += bytesToWrite;\n nextAddress += bytesToWrite;\n }\n\n return NO_PAGE_FAULT;\n }\n\n private getPage(access: Access, address: u32): PageData {\n const pageIdx = u32(address >> PAGE_SIZE_SHIFT);\n const relAddress = address % PAGE_SIZE;\n const pageStart = pageIdx << PAGE_SIZE_SHIFT;\n\n if (!this.pages.has(pageIdx)) {\n return new PageData(fault(pageStart), EMPTY_PAGE, relAddress);\n }\n\n const page = this.pages.get(pageIdx);\n if (!page.can(access)) {\n const f = fault(pageStart);\n f.isAccess = true;\n return new PageData(f, EMPTY_PAGE, relAddress);\n }\n\n return new PageData(NO_PAGE_FAULT, page, relAddress);\n }\n\n private getChunks(access: Access, address: u32, bytes: u8): Chunks {\n /**\n * Accessing empty set of bytes is always valid.\n * https://graypaper.fluffylabs.dev/#/68eaa1f/24a80024a800?v=0.6.4\n */\n if (bytes === 0) {\n return new Chunks(NO_PAGE_FAULT);\n }\n\n const pageData = this.getPage(access, address);\n if (pageData.fault.isFault) {\n return new Chunks(pageData.fault);\n }\n\n const page = pageData.page;\n const relativeAddress = pageData.relativeAddress;\n\n const endAddress = relativeAddress + u32(bytes);\n const needSecondPage = endAddress > PAGE_SIZE;\n\n // everything is on one page - easy case\n if (!needSecondPage) {\n const first = page.raw.data.subarray(relativeAddress, endAddress);\n return new Chunks(NO_PAGE_FAULT, first);\n }\n\n const secondPageIdx = u32((address + u32(bytes)) % MEMORY_SIZE) >> PAGE_SIZE_SHIFT;\n const secondPageStart = secondPageIdx << PAGE_SIZE_SHIFT;\n if (!this.pages.has(secondPageIdx)) {\n return new Chunks(fault(secondPageStart));\n }\n // fetch the second page and check access\n const secondPage = this.pages.get(secondPageIdx);\n if (!secondPage.can(access)) {\n const f = fault(secondPageStart);\n f.isAccess = true;\n return new Chunks(f);\n }\n\n const firstChunk = page.raw.data.subarray(relativeAddress);\n const secondChunk = secondPage.raw.data.subarray(0, relativeAddress + u32(bytes) - PAGE_SIZE);\n return new Chunks(NO_PAGE_FAULT, firstChunk, secondChunk);\n }\n\n private getBytes(access: Access, address: u32, bytes: u8): ChunkBytes {\n const res = this.getChunks(access, address, bytes);\n if (res.fault.isFault) {\n return new ChunkBytes(res.fault);\n }\n const data = getBytes(bytes, res.first, res.second);\n return new ChunkBytes(res.fault, data);\n }\n}\n\nfunction getBytes(bytes: u8, first: Uint8Array, second: Uint8Array): StaticArray {\n const res = new StaticArray(bytes);\n const len = first.length;\n for (let i = 0; i < len; i++) {\n res[i] = first[i];\n }\n for (let i = 0; i < second.length; i++) {\n res[len + i] = second[i];\n }\n return res;\n}\n\nfunction fault(address: u32): MaybePageFault {\n const r = new MaybePageFault();\n r.isFault = true;\n r.fault = address;\n return r;\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n readonly buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n readonly byteLength: i32;\n\n get byteOffset(): i32 {\n return (this.dataStart - changetype(this.buffer));\n }\n\n protected constructor(length: i32, alignLog2: i32) {\n if (length > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length = length << alignLog2, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = length;\n }\n}\n\n@final export class ArrayBuffer {\n\n static isView(value: T): bool {\n if (isNullable()) {\n if (changetype(value) == 0) return false;\n }\n if (value instanceof Int8Array) return true;\n if (value instanceof Uint8Array) return true;\n if (value instanceof Uint8ClampedArray) return true;\n if (value instanceof Int16Array) return true;\n if (value instanceof Uint16Array) return true;\n if (value instanceof Int32Array) return true;\n if (value instanceof Uint32Array) return true;\n if (value instanceof Int64Array) return true;\n if (value instanceof Uint64Array) return true;\n if (value instanceof Float32Array) return true;\n if (value instanceof Float64Array) return true;\n if (value instanceof DataView) return true;\n return false;\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n let buffer = changetype(__new(length, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, length);\n }\n return buffer;\n }\n\n get byteLength(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n }\n\n slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n let length = this.byteLength;\n begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n end = end < 0 ? max(length + end , 0) : min(end , length);\n let outSize = max(end - begin, 0);\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this) + begin, outSize);\n return out;\n }\n\n toString(): string {\n return \"[object ArrayBuffer]\";\n }\n}\n","import { Args } from \"../arguments\";\nimport { MaybePageFault, Memory } from \"../memory\";\nimport { Registers } from \"../registers\";\n\nexport type InstructionRun = (args: Args, registers: Registers, memory: Memory) => OutcomeData;\n\nexport enum Result {\n PANIC = 0,\n FAULT = 1,\n FAULT_ACCESS = 2,\n HOST = 3,\n}\n\nexport enum Outcome {\n Ok = 0,\n StaticJump = 1,\n DynamicJump = 2,\n Result = 3,\n}\n\n// @unmanaged\nexport class OutcomeData {\n outcome: Outcome = Outcome.Ok;\n staticJump: i32 = 0;\n dJump: u32 = 0;\n result: Result = Result.PANIC;\n exitCode: u32 = 0;\n}\n\nexport function status(result: Result): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = result;\n return r;\n}\n\nexport function staticJump(offset: i32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.StaticJump;\n r.staticJump = offset;\n return r;\n}\n\nexport function dJump(address: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.DynamicJump;\n r.dJump = address;\n return r;\n}\n\nexport function ok(): OutcomeData {\n return new OutcomeData();\n}\n\nexport function panic(): OutcomeData {\n return status(Result.PANIC);\n}\n\nexport function hostCall(id: u32): OutcomeData {\n const r = new OutcomeData();\n r.outcome = Outcome.Result;\n r.result = Result.HOST;\n r.exitCode = id;\n return r;\n}\n\nexport function okOrFault(pageFault: MaybePageFault): OutcomeData {\n const r = new OutcomeData();\n if (pageFault.isFault) {\n r.outcome = Outcome.Result;\n // not accessible memory does not result in `FAULT`, but rather goes straight to TRAP\n // yet in gas calculations we still subtract 1, unlike TRAP, but like FAULT.\n r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;\n r.exitCode = pageFault.fault;\n }\n return r;\n}\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u8SignExtend, u16SignExtend } from \"./utils\";\n\n// COUNT_SET_BITS_64\nexport const count_set_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(regs[reg(args.a)]);\n return ok();\n};\n\n// COUNT_SET_BITS_32\nexport const count_set_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = popcnt(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// LEADING_ZERO_BITS_64\nexport const leading_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(regs[reg(args.a)]);\n return ok();\n};\n\n// LEADING_ZERO_BITS_32\nexport const leading_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = clz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// TRAILING_ZERO_BITS_64\nexport const trailing_zero_bits_64: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(regs[reg(args.a)]);\n return ok();\n};\n\n// TRAILING_ZERO_BITS_32\nexport const trailing_zero_bits_32: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = ctz(u32(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_8\nexport const sign_extend_8: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));\n return ok();\n};\n\n// SIGN_EXTEND_16\nexport const sign_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// ZERO_EXTEND_16\nexport const zero_extend_16: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));\n return ok();\n};\n\n// REVERSE_BYTES\nexport const reverse_bytes: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = bswap(regs[reg(args.a)]);\n return ok();\n};\n","import { NO_OF_REGISTERS } from \"../registers\";\n\n/**\n * Multiply two unsigned 64-bit numbers and take the upper 64-bits of the result.\n * \n * The result of multiplication is a 128-bits number and we are only interested in the part that lands in the upper 64-bits.\n * For example (for 32-bit case) if we multiply `0xffffffff * 0xffffffff`, we get:\n \n * | 32-bits | 32-bits |\n * +------------+------------+\n * | upper | lower |\n * | 0xfffffffe | 0x00000001 |\n *\n * So `0xfffffffe` is returned.\n */\nexport function mulUpperUnsigned(a: u64, b: u64): u64 {\n const aHigh: u64 = a >> 32;\n const aLow: u64 = a & 0xffff_ffff;\n const bHigh: u64 = b >> 32;\n const bLow: u64 = b & 0xffff_ffff;\n\n const lowLow = aLow * bLow;\n const lowHigh = aLow * bHigh;\n const highLow = aHigh * bLow;\n const highHigh = aHigh * bHigh;\n const carry = (lowLow >> 32) + (lowHigh & 0xffff_ffff) + (highLow & 0xffff_ffff);\n\n return highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);\n}\n\n/**\n * Same as [mulUpperUnsigned] but treat the arguments as signed (two-complement) 64-bit numbers and the result alike.\n */\nexport function mulUpperSigned(a: i64, b: i64): u64 {\n let isResultNegative = false;\n let aAbs = a;\n let bAbs = b;\n if (a < 0) {\n isResultNegative = !isResultNegative;\n aAbs = ~a + 1;\n }\n if (b < 0) {\n isResultNegative = !isResultNegative;\n bAbs = ~b + 1;\n }\n\n if (isResultNegative) {\n const upper = mulUpperUnsigned(aAbs, bAbs);\n const lower = aAbs * bAbs;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n\n return mulUpperUnsigned(aAbs, bAbs);\n}\n\nexport function mulUpperSignedUnsigned(a: i64, b: u64): u64 {\n if (a < 0) {\n const aAbs: u64 = ~a + 1;\n const upper = mulUpperUnsigned(aAbs, b);\n const lower = aAbs * b;\n return ~upper + (lower === 0 ? 1 : 0);\n }\n return mulUpperUnsigned(a, b);\n}\n\n// @inline\nexport function u8SignExtend(v: u8): i64 {\n return i64(i32(i16(i8(v))));\n}\n\n// @inline\nexport function u16SignExtend(v: u16): i64 {\n return i64(i32(i16(v)));\n}\n\n// @inline\nexport function u32SignExtend(v: u32): i64 {\n return i64(i32(v));\n}\n\n// @inline\nexport function reg(v: u64): u32 {\n return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);\n}\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_HOLEYARRAY } from \"./util/error\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\n\n@final\nexport class StaticArray {\n [key: number]: T;\n\n // Note that the interface of StaticArray instances must be a semantically\n // compatible subset of Array in order for syntax highlighting to work\n // properly, for instance when creating static arrays from array literals.\n // The additionally provided static methods take care of dealing with static\n // arrays exclusively, without having to convert to Array first.\n\n static fromArray(source: Array): StaticArray {\n let length = source.length;\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (isManaged()) {\n let sourcePtr = source.dataStart;\n for (let i = 0; i < length; ++i) {\n let off = i << alignof();\n let ref = load(sourcePtr + off);\n store(changetype(out) + off, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(changetype(out), source.dataStart, outSize);\n }\n return out;\n }\n\n /** @deprecated Please use source.concat> instead. */\n static concat(source: StaticArray, other: StaticArray): StaticArray {\n return source.concat>(other);\n }\n\n /** @deprecated Please use source.slice> instead. */\n static slice(source: StaticArray, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n return source.slice>(start, end);\n }\n\n constructor(length: i32) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n let outSize = length << alignof();\n let out = changetype>(__new(outSize, idof>()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(out), 0, outSize);\n }\n return out;\n }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >>> alignof();\n }\n\n at(index: i32): T {\n let len = this.length;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(changetype(this) + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(changetype(this) + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length) throw new RangeError(E_INDEXOUTOFRANGE);\n this.__uset(index, value);\n }\n\n @unsafe @operator(\"{}=\") private __uset(index: i32, value: T): void {\n store(changetype(this) + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): StaticArray {\n if (isManaged()) {\n FILL(changetype(this), this.length, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(changetype(this), this.length, value, start, end);\n }\n return this;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): StaticArray {\n let ptr = changetype(this);\n let len = this.length;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return false;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n let elem = load(changetype(this) + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let length = this.length;\n if (length == 0 || fromIndex >= length) return -1;\n if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);\n while (fromIndex < length) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length): i32 {\n let length = this.length;\n if (length == 0) return -1;\n if (fromIndex < 0) fromIndex = length + fromIndex;\n else if (fromIndex >= length) fromIndex = length - 1;\n while (fromIndex >= 0) {\n if (load(changetype(this) + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n concat = Array>(other: U): U {\n let sourceLen = this.length;\n let otherLen = other.length;\n let outLen = sourceLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) {\n throw new Error(E_INVALIDLENGTH);\n }\n let sourceSize = sourceLen << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n out = changetype(__newArray(outLen, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n let otherStart = changetype>(other).dataStart;\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else if (out instanceof StaticArray) {\n out = changetype(__new(outLen << alignof(), idof>()));\n let outStart = changetype(out);\n let otherStart = changetype(other);\n let thisStart = changetype(this);\n\n if (isManaged()) {\n for (let offset: usize = 0; offset < sourceSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += sourceSize;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, thisStart, sourceSize);\n memory.copy(outStart + sourceSize, otherStart, otherLen << alignof());\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n slice = Array>(start: i32 = 0, end: i32 = i32.MAX_VALUE): U {\n let length = this.length;\n start = start < 0 ? max(start + length, 0) : min(start, length);\n end = end < 0 ? max(end + length, 0) : min(end, length);\n length = max(end - start, 0);\n\n let sourceStart = changetype(this) + (start << alignof());\n let size = length << alignof();\n let out = changetype(this); // FIXME: instanceof needs *some* value\n\n if (out instanceof Array) {\n // return Array\n out = changetype(__newArray(length, alignof(), idof>()));\n // ^ FIXME: Function returns type U, but can't __newArray(U extends Array)\n let outStart = changetype>(out).dataStart;\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(changetype(out), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else if (out instanceof StaticArray) {\n // return StaticArray\n out = changetype(__new(size, idof>()));\n let outStart = changetype(out);\n if (isManaged()) {\n let off: usize = 0;\n while (off < size) {\n let ref = load(sourceStart + off);\n store(outStart + off, ref);\n __link(outStart, ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(outStart, sourceStart, size);\n }\n } else {\n ERROR(\"Only Array and StaticArray accept for 'U' parameter\");\n }\n return out;\n }\n\n findIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: StaticArray) => bool): i32 {\n for (let i = this.length - 1; i >= 0; --i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n forEach(fn: (value: T, index: i32, array: StaticArray) => void): void {\n for (let i = 0, len = this.length; i < len; ++i) {\n fn(load(changetype(this) + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: StaticArray) => U): Array {\n let len = this.length;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < len; ++i) {\n let result = fn(load(changetype(this) + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: StaticArray) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length; i < len; ++i) {\n let value = load(changetype(this) + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length; i < len; ++i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: StaticArray) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length - 1; i >= 0; --i) {\n acc = fn(acc, load(changetype(this) + (i << alignof())), i, this);\n }\n return acc;\n }\n\n every(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (!fn(load(changetype(this) + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n some(fn: (value: T, index: i32, array: StaticArray) => bool): bool {\n for (let i = 0, len = this.length; i < len; ++i) {\n if (fn(load(changetype(this) + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): StaticArray {\n SORT(changetype(this), this.length, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n if (isBoolean()) return joinBooleanArray(changetype(this), this.length, separator);\n if (isInteger()) return joinIntegerArray(changetype(this), this.length, separator);\n if (isFloat()) return joinFloatArray(changetype(this), this.length, separator);\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(changetype(this), this.length, separator);\n }\n if (isReference()) return joinReferenceArray(changetype(this), this.length, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n reverse(): StaticArray {\n REVERSE(changetype(this), this.length);\n return this;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = changetype(this);\n let end = cur + changetype(changetype(this) - TOTAL_OVERHEAD).rtSize;\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n }\n}\n","export function bswap(value: T): T {\n if (isInteger()) {\n if (sizeof() == 1) {\n return value;\n }\n if (sizeof() == 2) {\n return (value << 8 | (value >> 8));\n }\n if (sizeof() == 4) {\n return (\n rotl(value & 0xFF00FF00, 8) |\n rotr(value & 0x00FF00FF, 8)\n );\n }\n if (sizeof() == 8) {\n let a = (value >> 8) & 0x00FF00FF00FF00FF;\n let b = (value & 0x00FF00FF00FF00FF) << 8;\n let v = a | b;\n\n a = (v >>> 16) & 0x0000FFFF0000FFFF;\n b = (v & 0x0000FFFF0000FFFF) << 16;\n\n return rotr(a | b, 32);\n }\n }\n ERROR(\"Unsupported generic type\");\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport {\n count_set_bits_32,\n count_set_bits_64,\n leading_zero_bits_32,\n leading_zero_bits_64,\n reverse_bytes,\n sign_extend_8,\n sign_extend_16,\n trailing_zero_bits_32,\n trailing_zero_bits_64,\n zero_extend_16,\n} from \"./bit\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"count_set_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 2 * 8 + 4);\n return assert;\n }),\n test(\"count_set_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = count_set_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 4);\n return assert;\n }),\n test(\"leading_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 16);\n return assert;\n }),\n test(\"leading_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xffff_0000_1111;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = leading_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 19);\n return assert;\n }),\n test(\"trailing_zero_bits_64\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 36);\n return assert;\n }),\n test(\"trailing_zero_bits_32\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_0000_0000;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = trailing_zero_bits_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 32);\n return assert;\n }),\n test(\"sign_extend_8\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_8(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_ffef);\n return assert;\n }),\n test(\"sign_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = sign_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xffff_ffff_ffff_beef);\n return assert;\n }),\n test(\"zero_extend_16\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = zero_extend_16(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0x0000_beef);\n return assert;\n }),\n test(\"reverse_bytes\", () => {\n // when\n const args = new Args();\n args.a = 0x1;\n args.b = 0xf;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfff0_dead_beef;\n const memo = new MemoryBuilder().build();\n\n // when\n const res = reverse_bytes(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(res.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(0xf)], 0xefbe_adde_f0ff_0000);\n return assert;\n }),\n];\n","export function HASH(key: T): u32 {\n if (isString()) {\n return hashStr(changetype(key));\n } else if (isReference()) {\n if (sizeof() == 4) return hash32(changetype(key));\n if (sizeof() == 8) return hash64(changetype(key));\n } else if (isFloat()) {\n if (sizeof() == 4) return hash32(reinterpret(f32(key)));\n if (sizeof() == 8) return hash64(reinterpret(f64(key)));\n } else {\n if (sizeof() <= 4) return hash32(u32(key), sizeof());\n if (sizeof() == 8) return hash64(u64(key));\n }\n return unreachable();\n}\n\n// XXHash 32-bit as a starting point, see: https://cyan4973.github.io/xxHash\n\n// primes\n// @ts-ignore: decorator\n@inline const XXH32_P1: u32 = 2654435761;\n// @ts-ignore: decorator\n@inline const XXH32_P2: u32 = 2246822519;\n// @ts-ignore: decorator\n@inline const XXH32_P3: u32 = 3266489917;\n// @ts-ignore: decorator\n@inline const XXH32_P4: u32 = 668265263;\n// @ts-ignore: decorator\n@inline const XXH32_P5: u32 = 374761393;\n// @ts-ignore: decorator\n@inline const XXH32_SEED: u32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction hash32(key: u32, len: u32 = 4): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + len;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hash64(key: u64): u32 {\n let h: u32 = XXH32_SEED + XXH32_P5 + 8;\n h += key * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h += (key >> 32) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction mix(h: u32, key: u32): u32 {\n return rotl(h + key * XXH32_P2, 13) * XXH32_P1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction hashStr(key: string): u32 {\n if (changetype(key) == 0) return XXH32_SEED;\n\n let h: u32 = key.length << 1;\n let len: usize = h;\n let pos = changetype(key);\n\n if (len >= 16) {\n let s1 = XXH32_SEED + XXH32_P1 + XXH32_P2;\n let s2 = XXH32_SEED + XXH32_P2;\n let s3 = XXH32_SEED;\n let s4 = XXH32_SEED - XXH32_P1;\n\n let end = len + pos - 16;\n while (pos <= end) {\n s1 = mix(s1, load(pos ));\n s2 = mix(s2, load(pos, 4));\n s3 = mix(s3, load(pos, 8));\n s4 = mix(s4, load(pos, 12));\n pos += 16;\n }\n h += rotl(s1, 1) + rotl(s2, 7) + rotl(s3, 12) + rotl(s4, 18);\n } else {\n h += XXH32_SEED + XXH32_P5;\n }\n\n let end = changetype(key) + len - 4;\n while (pos <= end) {\n h += load(pos) * XXH32_P3;\n h = rotl(h, 17) * XXH32_P4;\n pos += 4;\n }\n\n end = changetype(key) + len;\n while (pos < end) {\n h += load(pos) * XXH32_P5;\n h = rotl(h, 11) * XXH32_P1;\n pos++;\n }\n\n h ^= h >> 15;\n h *= XXH32_P2;\n h ^= h >> 13;\n h *= XXH32_P3;\n h ^= h >> 16;\n return h;\n}\n","/// \n\nimport { HASH } from \"./util/hash\";\nimport { E_KEYNOTFOUND } from \"./util/error\";\n\n// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht\n\n// @ts-ignore: decorator\n@inline const INITIAL_CAPACITY = 4;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_N = 8;\n\n// @ts-ignore: decorator\n@inline const FILL_FACTOR_D = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_N = 3;\n\n// @ts-ignore: decorator\n@inline const FREE_FACTOR_D = 4;\n\n/** Structure of a map entry. */\n@unmanaged class MapEntry {\n key: K;\n value: V;\n taggedNext: usize; // LSB=1 indicates EMPTY\n}\n\n/** Empty bit. */\n// @ts-ignore: decorator\n@inline const EMPTY: usize = 1 << 0;\n\n/** Size of a bucket. */\n// @ts-ignore: decorator\n@inline const BUCKET_SIZE = sizeof();\n\n/** Computes the alignment of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_ALIGN(): usize {\n // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits\n const maxkv = sizeof() > sizeof() ? sizeof() : sizeof();\n const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1;\n return align;\n}\n\n/** Computes the aligned size of an entry. */\n// @ts-ignore: decorator\n@inline\nfunction ENTRY_SIZE(): usize {\n const align = ENTRY_ALIGN();\n const size = (offsetof>() + align) & ~align;\n return size;\n}\n\nexport class Map {\n\n // buckets referencing their respective first entry, usize[bucketsMask + 1]\n private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n private bucketsMask: u32 = INITIAL_CAPACITY - 1;\n\n // entries in insertion order, MapEntry[entriesCapacity]\n private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n private entriesCapacity: i32 = INITIAL_CAPACITY;\n private entriesOffset: i32 = 0;\n private entriesCount: i32 = 0;\n\n constructor() {\n /* nop */\n }\n\n get size(): i32 {\n return this.entriesCount;\n }\n\n clear(): void {\n this.buckets = new ArrayBuffer(INITIAL_CAPACITY * BUCKET_SIZE);\n this.bucketsMask = INITIAL_CAPACITY - 1;\n this.entries = new ArrayBuffer(INITIAL_CAPACITY * ENTRY_SIZE());\n this.entriesCapacity = INITIAL_CAPACITY;\n this.entriesOffset = 0;\n this.entriesCount = 0;\n }\n\n private find(key: K, hashCode: u32): MapEntry | null {\n let entry = load>( // unmanaged!\n changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE\n );\n while (entry) {\n let taggedNext = entry.taggedNext;\n if (!(taggedNext & EMPTY) && entry.key == key) return entry;\n entry = changetype>(taggedNext & ~EMPTY);\n }\n return null;\n }\n\n has(key: K): bool {\n return this.find(key, HASH(key)) != null;\n }\n\n @operator(\"[]\")\n get(key: K): V {\n let entry = this.find(key, HASH(key));\n if (!entry) throw new Error(E_KEYNOTFOUND); // cannot represent `undefined`\n return entry.value;\n }\n\n @operator(\"[]=\")\n set(key: K, value: V): this {\n let hashCode = HASH(key);\n let entry = this.find(key, hashCode); // unmanaged!\n if (entry) {\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n } else {\n // check if rehashing is necessary\n if (this.entriesOffset == this.entriesCapacity) {\n this.rehash(\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ? this.bucketsMask // just rehash if 1/4+ entries are empty\n : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N\n );\n }\n // append new entry\n let entries = this.entries;\n entry = changetype>(changetype(entries) + (this.entriesOffset++) * ENTRY_SIZE());\n // link with the map\n entry.key = key;\n if (isManaged()) {\n __link(changetype(this), changetype(key), true);\n }\n entry.value = value;\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n ++this.entriesCount;\n // link with previous entry in bucket\n let bucketPtrBase = changetype(this.buckets) + (hashCode & this.bucketsMask) * BUCKET_SIZE;\n entry.taggedNext = load(bucketPtrBase);\n store(bucketPtrBase, changetype(entry));\n }\n return this;\n }\n\n delete(key: K): bool {\n let entry = this.find(key, HASH(key));\n if (!entry) return false;\n entry.taggedNext |= EMPTY;\n --this.entriesCount;\n // check if rehashing is appropriate\n let halfBucketsMask = this.bucketsMask >> 1;\n if (\n halfBucketsMask + 1 >= max(INITIAL_CAPACITY, this.entriesCount) &&\n this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D\n ) this.rehash(halfBucketsMask);\n return true;\n }\n\n private rehash(newBucketsMask: u32): void {\n let newBucketsCapacity = (newBucketsMask + 1);\n let newBuckets = new ArrayBuffer(newBucketsCapacity * BUCKET_SIZE);\n let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;\n let newEntries = new ArrayBuffer(newEntriesCapacity * ENTRY_SIZE());\n\n // copy old entries to new entries\n let oldPtr = changetype(this.entries);\n let oldEnd = oldPtr + this.entriesOffset * ENTRY_SIZE();\n let newPtr = changetype(newEntries);\n while (oldPtr != oldEnd) {\n let oldEntry = changetype>(oldPtr);\n if (!(oldEntry.taggedNext & EMPTY)) {\n let newEntry = changetype>(newPtr);\n let oldEntryKey = oldEntry.key;\n newEntry.key = oldEntryKey;\n newEntry.value = oldEntry.value;\n let newBucketIndex = HASH(oldEntryKey) & newBucketsMask;\n let newBucketPtrBase = changetype(newBuckets) + newBucketIndex * BUCKET_SIZE;\n newEntry.taggedNext = load(newBucketPtrBase);\n store(newBucketPtrBase, newPtr);\n newPtr += ENTRY_SIZE();\n }\n oldPtr += ENTRY_SIZE();\n }\n\n this.buckets = newBuckets;\n this.bucketsMask = newBucketsMask;\n this.entries = newEntries;\n this.entriesCapacity = newEntriesCapacity;\n this.entriesOffset = this.entriesCount;\n }\n\n keys(): K[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let keys = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(keys[length++] = entry.key);\n }\n }\n keys.length = length;\n return keys;\n }\n\n values(): V[] {\n // FIXME: this is preliminary, needs iterators/closures\n let start = changetype(this.entries);\n let size = this.entriesOffset;\n let values = new Array(size);\n let length = 0;\n for (let i = 0; i < size; ++i) {\n let entry = changetype>(start + i * ENTRY_SIZE());\n if (!(entry.taggedNext & EMPTY)) {\n unchecked(values[length++] = entry.value);\n }\n }\n values.length = length;\n return values;\n }\n\n toString(): string {\n return \"[object Map]\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n __visit(changetype(this.buckets), cookie);\n let entries = changetype(this.entries);\n if (isManaged() || isManaged()) {\n let cur = entries;\n let end = cur + this.entriesOffset * ENTRY_SIZE();\n while (cur < end) {\n let entry = changetype>(cur);\n if (!(entry.taggedNext & EMPTY)) {\n if (isManaged()) {\n let val = changetype(entry.key);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n if (isManaged()) {\n let val = changetype(entry.value);\n if (isNullable()) {\n if (val) __visit(val, cookie);\n } else __visit(val, cookie);\n }\n }\n cur += ENTRY_SIZE();\n }\n }\n __visit(entries, cookie);\n }\n}\n","/// \n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n // Depends on the fact that Arrays mimic ArrayBufferView\n let oldCapacity = changetype(array).byteLength;\n if (newSize > oldCapacity >>> alignLog2) {\n if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n let oldData = changetype(changetype(array).buffer);\n // Grows old capacity by factor of two.\n // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n let newData = __renew(oldData, newCapacity);\n // __new / __renew already init memory range as zeros in Incremental runtime.\n // So try to avoid this.\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n }\n if (newData != oldData) { // oldData has been free'd\n store(array, newData, offsetof(\"buffer\"));\n store(array, newData, offsetof(\"dataStart\"));\n __link(array, changetype(newData), false);\n }\n store(array, newCapacity, offsetof(\"byteLength\"));\n }\n}\n\nexport class Array {\n [key: number]: T;\n\n // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n private buffer: ArrayBuffer;\n @unsafe readonly dataStart: usize;\n private byteLength: i32; // Uses here as capacity\n\n // Also note that Array with non-nullable T must guard against uninitialized null values\n // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n private length_: i32;\n\n static isArray(value: U): bool {\n return isReference() ? changetype(value) != 0 && builtin_isArray(value) : false;\n }\n\n static create(capacity: i32 = 0): Array {\n WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n let array = new Array(capacity);\n array.length = 0;\n return array;\n }\n\n constructor(length: i32 = 0) {\n if (length > BLOCK_MAXSIZE >>> alignof()) throw new RangeError(E_INVALIDLENGTH);\n // reserve capacity for at least MIN_SIZE elements\n let bufferSize = max(length, MIN_SIZE) << alignof();\n let buffer = changetype(__new(bufferSize, idof()));\n if (ASC_RUNTIME != Runtime.Incremental) {\n memory.fill(changetype(buffer), 0, bufferSize);\n }\n this.buffer = buffer; // links\n this.dataStart = changetype(buffer);\n this.byteLength = bufferSize;\n this.length_ = length;\n }\n\n get length(): i32 {\n return this.length_;\n }\n\n set length(newLength: i32) {\n ensureCapacity(changetype(this), newLength, alignof(), false);\n this.length_ = newLength;\n }\n\n every(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (!fn(load(this.dataStart + (i << alignof())), i, this)) return false;\n }\n return true;\n }\n\n findIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n findLastIndex(fn: (value: T, index: i32, array: Array) => bool): i32 {\n for (let i = this.length_ - 1; i >= 0; --i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return i;\n }\n return -1;\n }\n\n @operator(\"[]\") private __get(index: i32): T {\n if (index >= this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n @unsafe @operator(\"{}\") private __uget(index: i32): T {\n return load(this.dataStart + (index << alignof()));\n }\n\n @operator(\"[]=\") private __set(index: i32, value: T): void {\n if (index >= this.length_) {\n if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n ensureCapacity(changetype(this), index + 1, alignof());\n this.length_ = index + 1;\n }\n store(this.dataStart + (index << alignof()), value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n }\n\n at(index: i32): T {\n let len = this.length_;\n index += select(0, len, index >= 0);\n if (index >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let value = load(this.dataStart + (index << alignof()));\n if (isReference()) {\n if (!isNullable()) {\n if (!changetype(value)) throw new Error(E_HOLEYARRAY);\n }\n }\n return value;\n }\n\n fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (isManaged()) {\n FILL(this.dataStart, this.length_, changetype(value), start, end);\n __link(changetype(this), changetype(value), false);\n } else {\n FILL(this.dataStart, this.length_, value, start, end);\n }\n return this;\n }\n\n includes(value: T, fromIndex: i32 = 0): bool {\n if (isFloat()) {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return false;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n let elem = load(ptr + (fromIndex << alignof()));\n // @ts-ignore\n if (elem == value || isNaN(elem) & isNaN(value)) return true;\n ++fromIndex;\n }\n return false;\n } else {\n return this.indexOf(value, fromIndex) >= 0;\n }\n }\n\n indexOf(value: T, fromIndex: i32 = 0): i32 {\n let len = this.length_;\n if (len == 0 || fromIndex >= len) return -1;\n if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n let ptr = this.dataStart;\n while (fromIndex < len) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n let len = this.length_;\n if (len == 0) return -1;\n if (fromIndex < 0) fromIndex = len + fromIndex;\n else if (fromIndex >= len) fromIndex = len - 1;\n let ptr = this.dataStart;\n while (fromIndex >= 0) {\n if (load(ptr + (fromIndex << alignof())) == value) return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(value: T): i32 {\n let oldLen = this.length_;\n let len = oldLen + 1;\n ensureCapacity(changetype(this), len, alignof());\n if (isManaged()) {\n store(this.dataStart + (oldLen << alignof()), changetype(value));\n __link(changetype(this), changetype(value), true);\n } else {\n store(this.dataStart + (oldLen << alignof()), value);\n }\n this.length_ = len;\n return len;\n }\n\n concat(other: Array): Array {\n let thisLen = this.length_;\n let otherLen = other.length_;\n let outLen = thisLen + otherLen;\n if (outLen > BLOCK_MAXSIZE >>> alignof()) throw new Error(E_INVALIDLENGTH);\n let out = changetype>(__newArray(outLen, alignof(), idof>()));\n let outStart = out.dataStart;\n let thisSize = thisLen << alignof();\n if (isManaged()) {\n let thisStart = this.dataStart;\n for (let offset: usize = 0; offset < thisSize; offset += sizeof()) {\n let ref = load(thisStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n outStart += thisSize;\n let otherStart = other.dataStart;\n let otherSize = otherLen << alignof();\n for (let offset: usize = 0; offset < otherSize; offset += sizeof()) {\n let ref = load(otherStart + offset);\n store(outStart + offset, ref);\n __link(changetype(out), ref, true);\n }\n } else {\n memory.copy(outStart, this.dataStart, thisSize);\n memory.copy(outStart + thisSize, other.dataStart, otherLen << alignof());\n }\n return out;\n }\n\n copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array {\n let ptr = this.dataStart;\n let len = this.length_;\n\n end = min(end, len);\n\n let to = target < 0 ? max(len + target, 0) : min(target, len);\n let from = start < 0 ? max(len + start, 0) : min(start, len);\n let last = end < 0 ? max(len + end, 0) : min(end, len);\n let count = min(last - from, len - to);\n\n memory.copy( // is memmove\n ptr + (to << alignof()),\n ptr + (from << alignof()),\n count << alignof()\n );\n return this;\n }\n\n pop(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let val = load(this.dataStart + ((--len) << alignof()));\n this.length_ = len;\n return val;\n }\n\n forEach(fn: (value: T, index: i32, array: Array) => void): void {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n fn(load(this.dataStart + (i << alignof())), i, this);\n }\n }\n\n map(fn: (value: T, index: i32, array: Array) => U): Array {\n let len = this.length_;\n let out = changetype>(__newArray(len, alignof(), idof>()));\n let outStart = out.dataStart;\n for (let i = 0; i < min(len, this.length_); ++i) {\n let result = fn(load(this.dataStart + (i << alignof())), i, this);\n store(outStart + (i << alignof()), result);\n if (isManaged()) {\n __link(changetype(out), changetype(result), true);\n }\n }\n return out;\n }\n\n filter(fn: (value: T, index: i32, array: Array) => bool): Array {\n let result = changetype>(__newArray(0, alignof(), idof>()));\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n let value = load(this.dataStart + (i << alignof()));\n if (fn(value, i, this)) result.push(value);\n }\n return result;\n }\n\n reduce(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n reduceRight(\n fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array) => U,\n initialValue: U\n ): U {\n let acc = initialValue;\n for (let i = this.length_ - 1; i >= 0; --i) {\n acc = fn(acc, load(this.dataStart + (i << alignof())), i, this);\n }\n return acc;\n }\n\n shift(): T {\n let len = this.length_;\n if (len < 1) throw new RangeError(E_EMPTYARRAY);\n let base = this.dataStart;\n let element = load(base);\n let lastIndex = len - 1;\n memory.copy(\n base,\n base + sizeof(),\n lastIndex << alignof()\n );\n if (isReference()) {\n store(base + (lastIndex << alignof()), 0);\n } else {\n // @ts-ignore\n store(base + (lastIndex << alignof()), 0);\n }\n this.length_ = lastIndex;\n return element;\n }\n\n some(fn: (value: T, index: i32, array: Array) => bool): bool {\n for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n if (fn(load(this.dataStart + (i << alignof())), i, this)) return true;\n }\n return false;\n }\n\n unshift(value: T): i32 {\n let len = this.length_ + 1;\n ensureCapacity(changetype(this), len, alignof());\n let ptr = this.dataStart;\n memory.copy(\n ptr + sizeof(),\n ptr,\n (len - 1) << alignof()\n );\n store(ptr, value);\n if (isManaged()) {\n __link(changetype(this), changetype(value), true);\n }\n this.length_ = len;\n return len;\n }\n\n slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end , len);\n len = max(end - start, 0);\n let slice = changetype>(__newArray(len, alignof(), idof>()));\n let sliceBase = slice.dataStart;\n let thisBase = this.dataStart + (start << alignof());\n if (isManaged()) {\n let off = 0;\n let end = len << alignof();\n while (off < end) {\n let ref = load(thisBase + off);\n store(sliceBase + off, ref);\n __link(changetype(slice), ref, true);\n off += sizeof();\n }\n } else {\n memory.copy(sliceBase, thisBase, len << alignof());\n }\n return slice;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array {\n let len = this.length_;\n start = start < 0 ? max(len + start, 0) : min(start, len);\n deleteCount = max(min(deleteCount, len - start), 0);\n let result = changetype>(__newArray(deleteCount, alignof(), idof>()));\n let resultStart = result.dataStart;\n let thisStart = this.dataStart;\n let thisBase = thisStart + (start << alignof());\n memory.copy(\n resultStart,\n thisBase,\n deleteCount << alignof()\n );\n let offset = start + deleteCount;\n if (len != offset) {\n memory.copy(\n thisBase,\n thisStart + (offset << alignof()),\n (len - offset) << alignof()\n );\n }\n this.length_ = len - deleteCount;\n return result;\n }\n\n reverse(): Array {\n REVERSE(this.dataStart, this.length_);\n return this;\n }\n\n sort(comparator: (a: T, b: T) => i32 = COMPARATOR()): Array {\n SORT(this.dataStart, this.length_, comparator);\n return this;\n }\n\n join(separator: string = \",\"): string {\n let ptr = this.dataStart;\n let len = this.length_;\n if (isBoolean()) return joinBooleanArray(ptr, len, separator);\n if (isInteger()) return joinIntegerArray(ptr, len, separator);\n if (isFloat()) return joinFloatArray(ptr, len, separator);\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (isString()) return joinStringArray(ptr, len, separator);\n }\n // For rest objects and arrays use general join routine\n if (isReference()) return joinReferenceArray(ptr, len, separator);\n ERROR(\"unspported element type\");\n return unreachable();\n }\n\n flat(): T {\n if (!isArray()) {\n ERROR(\"Cannot call flat() on Array where T is not an Array.\");\n }\n // Get the length and data start values\n let ptr = this.dataStart;\n let len = this.length_;\n\n // calculate the end size with an initial pass\n let size = 0;\n for (let i = 0; i < len; ++i) {\n let child = load(ptr + (i << alignof()));\n size += child == 0 ? 0 : load(child, offsetof(\"length_\"));\n }\n\n // calculate the byteLength of the resulting backing ArrayBuffer\n const align = alignof>();\n let byteLength = size << align;\n let outBuffer = changetype(__new(byteLength, idof()));\n\n // create the return value and initialize it\n let outArray = changetype(__new(offsetof(), idof()));\n store(changetype(outArray), size, offsetof(\"length_\"));\n\n // byteLength, dataStart, and buffer are all readonly\n store(changetype(outArray), byteLength, offsetof(\"byteLength\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"dataStart\"));\n store(changetype(outArray), changetype(outBuffer), offsetof(\"buffer\"));\n __link(changetype(outArray), changetype(outBuffer), false);\n\n // set the elements\n let resultOffset: usize = 0;\n for (let i = 0; i < len; ++i) { // for each child\n let child = load(ptr + (i << alignof()));\n\n // ignore null arrays\n if (!child) continue;\n\n // copy the underlying buffer data to the result buffer\n let childDataLength = load(child, offsetof(\"length_\")) << align;\n memory.copy(\n changetype(outBuffer) + resultOffset,\n load(child, offsetof(\"dataStart\")),\n childDataLength\n );\n\n // advance the result length\n resultOffset += childDataLength;\n }\n\n // if the `valueof` type is managed, we must link each reference\n if (isManaged>()) {\n for (let i = 0; i < size; ++i) {\n let ref = load(changetype(outBuffer) + (i << usize(alignof>())));\n __link(changetype(outBuffer), ref, true);\n }\n }\n\n return outArray;\n }\n\n toString(): string {\n return this.join();\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n if (isManaged()) {\n let cur = this.dataStart;\n let end = cur + (this.length_ << alignof());\n while (cur < end) {\n let val = load(cur);\n if (val) __visit(val, cookie);\n cur += sizeof();\n }\n }\n __visit(changetype(this.buffer), cookie);\n }\n}\n","export class Test {\n constructor(\n public name: string,\n public ptr: (assert: Assert) => Assert,\n ) {}\n}\n\nexport class Assert {\n public isOkay: boolean = true;\n public errors: string[] = [];\n\n static todo(): Assert {\n const r = new Assert();\n r.fail(\"Not implemented yet!\");\n return r;\n }\n\n fail(msg: string): void {\n this.isOkay = false;\n this.errors.push(msg);\n }\n\n isArrayEqual(actual: T[], expected: T[], msg: string = \"\"): void {\n this.isEqual(actual.length, expected.length, `length @ ${msg}`);\n this.isEqual(actual.join(\",\").toString(), expected.join(\",\").toString(), msg);\n }\n\n isEqual(actual: T, expected: T, msg: string = \"\"): void {\n if (actual !== expected) {\n this.isOkay = false;\n const actualDisplay = isInteger(actual) ? `${actual} (0x${actual.toString(16)})` : `${actual}`;\n const expectDisplay = isInteger(expected) ? `${expected} (0x${expected.toString(16)})` : `${expected}`;\n this.errors.push(`Got: '${actualDisplay}', expected: '${expectDisplay}' @ ${msg}`);\n }\n }\n}\n\nexport function test(name: string, ptr: (assert: Assert) => Assert): Test {\n return new Test(name, ptr);\n}\n","import { itoa32, utoa32, itoa64, utoa64, dtoa } from \"./util/number\";\nimport { strtol, strtod } from \"./util/string\";\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const NaN: f64 = 0 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin @inline\nexport const Infinity: f64 = 1 / 0; // context-aware\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNaN(value: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@final @unmanaged\nexport abstract class I8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i8 = i8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i8 = i8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i8 {\n return strtol(value, radix);\n }\n\n toString(this: i8, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i16 = i16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i16 = i16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i16 {\n return strtol(value, radix);\n }\n\n toString(this: i16, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i32 = i32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i32 = i32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i32 {\n return strtol(value, radix);\n }\n\n toString(this: i32, radix: i32 = 10): String {\n return itoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class I64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: i64 = i64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: i64 = i64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): i64 {\n return strtol(value, radix);\n }\n\n toString(this: i64, radix: i32 = 10): String {\n return itoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Isize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: isize = isize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: isize = isize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): isize {\n return strtol(value, radix);\n }\n\n toString(this: isize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return itoa32(this, radix);\n } else {\n return itoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class U8 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u8 = u8.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u8 = u8.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u8 {\n return strtol(value, radix);\n }\n\n toString(this: u8, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U16 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u16 = u16.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u16 = u16.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u16 {\n return strtol(value, radix);\n }\n\n toString(this: u16, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u32 = u32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u32 = u32.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u32 {\n return strtol(value, radix);\n }\n\n toString(this: u32, radix: i32 = 10): String {\n return utoa32(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class U64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: u64 = u64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: u64 = u64.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): u64 {\n return strtol(value, radix);\n }\n\n toString(this: u64, radix: i32 = 10): String {\n return utoa64(this, radix);\n }\n}\n\n@final @unmanaged\nexport abstract class Usize {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: usize = usize.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: usize = usize.MAX_VALUE;\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): usize {\n return strtol(value, radix);\n }\n\n toString(this: usize, radix: i32 = 10): String {\n if (sizeof() == 4) {\n return utoa32(this, radix);\n } else {\n return utoa64(this, radix);\n }\n }\n}\n\n@final @unmanaged\nexport abstract class Bool {\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: bool = bool.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: bool = bool.MAX_VALUE;\n\n toString(this: bool, radix: i32 = 0): String {\n return this ? \"true\" : \"false\";\n }\n}\n\nexport { Bool as Boolean };\n\n@final @unmanaged\nexport abstract class F32 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f32 = f32.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f32 = f32.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f32 = f32.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f32 = f32.NaN;\n\n static isNaN(value: f32): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f32): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f32): bool {\n return abs(value) <= f32.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f32): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f32 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f32 {\n return strtod(value);\n }\n\n toString(this: f32, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\n@final @unmanaged\nexport abstract class F64 {\n\n // @ts-ignore: decorator\n @lazy\n static readonly EPSILON: f64 = f64.EPSILON;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_VALUE: f64 = f64.MIN_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_VALUE: f64 = f64.MAX_VALUE;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;\n\n // @ts-ignore: decorator\n @lazy\n static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;\n\n // @ts-ignore: decorator\n @lazy\n static readonly NaN: f64 = f64.NaN;\n\n static isNaN(value: f64): bool {\n return isNaN(value);\n }\n\n static isFinite(value: f64): bool {\n return isFinite(value);\n }\n\n static isSafeInteger(value: f64): bool {\n return abs(value) <= f64.MAX_SAFE_INTEGER && trunc(value) == value;\n }\n\n static isInteger(value: f64): bool {\n return isFinite(value) && trunc(value) == value;\n }\n\n /** @deprecated */\n static parseInt(value: string, radix: i32 = 0): f64 {\n return strtol(value, radix);\n }\n\n /** @deprecated */\n static parseFloat(value: string): f64 {\n return strtod(value);\n }\n\n toString(this: f64, radix: i32 = 0): String {\n return dtoa(this);\n }\n}\n\nexport { F64 as Number };\n","/// \n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { compareImpl, strtol, strtod, isSpace, isAscii, isFinalSigma, toLower8, toUpper8 } from \"./util/string\";\nimport { SPECIALS_UPPER, casemap, bsearch } from \"./util/casemap\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_UNPAIRED_SURROGATE } from \"./util/error\";\nimport { idof } from \"./builtins\";\nimport { Array } from \"./array\";\n\n@final export abstract class String {\n\n @lazy static readonly MAX_LENGTH: i32 = (BLOCK_MAXSIZE >>> alignof());\n\n static fromCharCode(unit: i32, surr: i32 = -1): String {\n let hasSur = surr > 0;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n store(changetype(out), unit);\n if (hasSur) store(changetype(out), surr, 2);\n return out;\n }\n\n static fromCharCodes(units: Array): String {\n let length = units.length;\n let out = changetype(__new(length << 1, idof()));\n let ptr = units.dataStart;\n for (let i = 0; i < length; ++i) {\n store(changetype(out) + (i << 1), load(ptr + (i << 2)));\n }\n return out;\n }\n\n static fromCodePoint(code: i32): String {\n let hasSur = code > 0xFFFF;\n let out = changetype(__new(2 << i32(hasSur), idof()));\n if (!hasSur) {\n store(changetype(out), code);\n } else {\n // Checks valid code point range\n assert(code <= 0x10FFFF);\n code -= 0x10000;\n let hi = (code & 0x03FF) | 0xDC00;\n let lo = code >>> 10 | 0xD800;\n store(changetype(out), lo | hi << 16);\n }\n return out;\n }\n\n @builtin static raw(parts: TemplateStringsArray, ...args: unknown[]): string { return unreachable(); }\n\n get length(): i32 {\n return changetype(changetype(this) - TOTAL_OVERHEAD).rtSize >> 1;\n }\n\n at(pos: i32): String {\n let len = this.length;\n pos += select(0, len, pos >= 0);\n if (pos >= len) throw new RangeError(E_INDEXOUTOFRANGE);\n let out = __new(2, idof());\n store(out, load(changetype(this) + (pos << 1)));\n return changetype(out); // retains\n }\n\n @operator(\"[]\") charAt(pos: i32): String {\n if (pos >= this.length) return changetype(\"\");\n let out = changetype(__new(2, idof()));\n store(changetype(out), load(changetype(this) + (pos << 1)));\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n if (pos >= this.length) return -1; // (NaN)\n return load(changetype(this) + (pos << 1));\n }\n\n codePointAt(pos: i32): i32 {\n let len = this.length;\n if (pos >= len) return -1; // (undefined)\n let first = load(changetype(this) + (pos << 1));\n if ((first & 0xFC00) != 0xD800 || pos + 1 == len) return first;\n let second = load(changetype(this) + (pos << 1), 2);\n if ((second & 0xFC00) != 0xDC00) return first;\n return (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator(\"+\") private static __concat(left: String, right: String): String {\n return left.concat(right);\n }\n\n concat(other: String): String {\n let thisSize: isize = this.length << 1;\n let otherSize: isize = other.length << 1;\n let outSize: usize = thisSize + otherSize;\n if (outSize == 0) return changetype(\"\");\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n memory.copy(changetype(out) + thisSize, changetype(other), otherSize);\n return out;\n }\n\n endsWith(search: String, end: i32 = String.MAX_LENGTH): bool {\n end = min(max(end, 0), this.length);\n let searchLength = search.length;\n let searchStart = end - searchLength;\n if (searchStart < 0) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n @operator(\"==\") private static __eq(left: String | null, right: String | null): bool {\n if (changetype(left) == changetype(right)) return true;\n if (changetype(left) == 0 || changetype(right) == 0) return false;\n let leftLength = changetype(left).length;\n if (leftLength != changetype(right).length) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(left, 0, right, 0, leftLength);\n }\n\n @operator.prefix(\"!\")\n private static __not(str: String | null): bool {\n return changetype(str) == 0 || !changetype(str).length;\n }\n\n @operator(\"!=\")\n private static __ne(left: String | null, right: String | null): bool {\n return !this.__eq(left, right);\n }\n\n @operator(\">\") private static __gt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let leftLength = left.length;\n if (!leftLength) return false;\n let rightLength = right.length;\n if (!rightLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res > 0 : leftLength > rightLength;\n }\n\n @operator(\">=\") private static __gte(left: String, right: String): bool {\n return !this.__lt(left, right);\n }\n\n @operator(\"<\") private static __lt(left: String, right: String): bool {\n if (changetype(left) == changetype(right)) return false;\n let rightLength = right.length;\n if (!rightLength) return false;\n let leftLength = left.length;\n if (!leftLength) return true;\n // @ts-ignore: string <-> String\n let res = compareImpl(left, 0, right, 0, min(leftLength, rightLength));\n return res ? res < 0 : leftLength < rightLength;\n }\n\n @operator(\"<=\") private static __lte(left: String, right: String): bool {\n return !this.__gt(left, right);\n }\n\n includes(search: String, start: i32 = 0): bool {\n return this.indexOf(search, start) != -1;\n }\n\n indexOf(search: String, start: i32 = 0): i32 {\n let searchLen = search.length;\n if (!searchLen) return 0;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len);\n for (len -= searchLen; searchStart <= len; ++searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n lastIndexOf(search: String, start: i32 = i32.MAX_VALUE): i32 {\n let searchLen = search.length;\n if (!searchLen) return this.length;\n let len = this.length;\n if (!len) return -1;\n let searchStart = min(max(start, 0), len - searchLen);\n for (; searchStart >= 0; --searchStart) {\n // @ts-ignore: string <-> String\n if (!compareImpl(this, searchStart, search, 0, searchLen)) return searchStart;\n }\n return -1;\n }\n\n // TODO: implement full locale comparison with locales and Collator options\n localeCompare(other: String): i32 {\n if (changetype(other) == changetype(this)) return 0;\n let alen = this.length;\n let blen = other.length;\n // @ts-ignore: string <-> String\n let res = compareImpl(this, 0, other, 0, min(alen, blen));\n res = res ? res : alen - blen;\n // normalize to [-1, 1] range\n return i32(res > 0) - i32(res < 0);\n }\n\n startsWith(search: String, start: i32 = 0): bool {\n let len = this.length;\n let searchStart = min(max(start, 0), len);\n let searchLength = search.length;\n if (searchLength + searchStart > len) return false;\n // @ts-ignore: string <-> String\n return !compareImpl(this, searchStart, search, 0, searchLength);\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String { // legacy\n let intStart: isize = start;\n let end: isize = length;\n let len: isize = this.length;\n if (intStart < 0) intStart = max(len + intStart, 0);\n let size = min(max(end, 0), len - intStart) << 1;\n if (size <= 0) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + (intStart << 1), size);\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len: isize = this.length;\n let finalStart = min(max(start, 0), len);\n let finalEnd = min(max(end, 0), len);\n let fromPos = min(finalStart, finalEnd) << 1;\n let toPos = max(finalStart, finalEnd) << 1;\n let size = toPos - fromPos;\n if (!size) return changetype(\"\");\n if (!fromPos && toPos == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + fromPos, size);\n return out;\n }\n\n trim(): String {\n let len = this.length;\n let size: usize = len << 1;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2; size -= 2;\n }\n if (!size) return changetype(\"\");\n if (!offset && size == len << 1) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n @inline\n trimLeft(): String {\n return this.trimStart();\n }\n\n @inline\n trimRight(): String {\n return this.trimEnd();\n }\n\n trimStart(): String {\n let size = this.length << 1;\n let offset: usize = 0;\n while (offset < size && isSpace(load(changetype(this) + offset))) {\n offset += 2;\n }\n if (!offset) return this;\n size -= offset;\n if (!size) return changetype(\"\");\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this) + offset, size);\n return out;\n }\n\n trimEnd(): String {\n let originalSize = this.length << 1;\n let size = originalSize;\n while (size && isSpace(load(changetype(this) + size - 2))) {\n size -= 2;\n }\n if (!size) return changetype(\"\");\n if (size == originalSize) return this;\n let out = changetype(__new(size, idof()));\n memory.copy(changetype(out), changetype(this), size);\n return out;\n }\n\n padStart(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let prependSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n if (prependSize > padSize) {\n let repeatCount = (prependSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = prependSize - restBase;\n memory.repeat(changetype(out), changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out), changetype(pad), prependSize);\n }\n memory.copy(changetype(out) + prependSize, changetype(this), thisSize);\n return out;\n }\n\n padEnd(length: i32, pad: string = \" \"): String {\n let thisSize = this.length << 1;\n let targetSize = length << 1;\n let padSize = pad.length << 1;\n if (targetSize < thisSize || !padSize) return this;\n let appendSize = targetSize - thisSize;\n let out = changetype(__new(targetSize, idof()));\n memory.copy(changetype(out), changetype(this), thisSize);\n if (appendSize > padSize) {\n let repeatCount = (appendSize - 2) / padSize;\n let restBase = repeatCount * padSize;\n let restSize = appendSize - restBase;\n memory.repeat(changetype(out) + thisSize, changetype(pad), padSize, repeatCount);\n memory.copy(changetype(out) + thisSize + restBase, changetype(pad), restSize);\n } else {\n memory.copy(changetype(out) + thisSize, changetype(pad), appendSize);\n }\n return out;\n }\n\n repeat(count: i32 = 0): String {\n let length = this.length;\n\n // Most browsers can't handle strings 1 << 28 chars or longer\n if (count < 0 || length * count > (1 << 28)) {\n throw new RangeError(E_INVALIDLENGTH);\n }\n\n if (count == 0 || !length) return changetype(\"\");\n if (count == 1) return this;\n let out = changetype(__new((length * count) << 1, idof()));\n memory.repeat(changetype(out), changetype(this), length << 1, count);\n return out;\n }\n\n replace(search: String, replacement: String): String {\n let len: usize = this.length;\n let slen: usize = search.length;\n if (len <= slen) {\n return len < slen ? this : select(replacement, this, search == this);\n }\n let index: isize = this.indexOf(search);\n if (~index) {\n let rlen: usize = replacement.length;\n len -= slen;\n let olen = len + rlen;\n if (olen) {\n let out = changetype(__new(olen << 1, idof()));\n memory.copy(changetype(out), changetype(this), index << 1);\n memory.copy(\n changetype(out) + (index << 1),\n changetype(replacement),\n rlen << 1\n );\n memory.copy(\n changetype(out) + ((index + rlen) << 1),\n changetype(this) + ((index + slen) << 1),\n (len - index) << 1\n );\n return out;\n }\n }\n return this;\n }\n\n replaceAll(search: String, replacement: String): String {\n let thisLen: usize = this.length;\n let searchLen: usize = search.length;\n if (thisLen <= searchLen) {\n return thisLen < searchLen\n ? this\n : select(replacement, this, search == this);\n }\n let replaceLen: usize = replacement.length;\n if (!searchLen) {\n if (!replaceLen) return this;\n // Special case: 'abc'.replaceAll('', '-') -> '-a-b-c-'\n let out = changetype(__new((thisLen + (thisLen + 1) * replaceLen) << 1, idof()));\n memory.copy(changetype(out), changetype(replacement), replaceLen << 1);\n let offset = replaceLen;\n for (let i: usize = 0; i < thisLen; ++i) {\n store(\n changetype(out) + (offset++ << 1),\n load(changetype(this) + (i << 1))\n );\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n }\n return out;\n }\n let prev: isize = 0, next: isize = 0;\n if (searchLen == replaceLen) {\n // Fast path when search and replacement have same length\n let outSize = thisLen << 1;\n let out = changetype(__new(outSize, idof()));\n memory.copy(changetype(out), changetype(this), outSize);\n while (~(next = this.indexOf(search, prev))) {\n memory.copy(changetype(out) + (next << 1), changetype(replacement), replaceLen << 1);\n prev = next + searchLen;\n }\n return out;\n }\n let out: String | null = null, offset: usize = 0, outSize = thisLen;\n while (~(next = this.indexOf(search, prev))) {\n if (!out) out = changetype(__new(thisLen << 1, idof()));\n let chunk = next - prev;\n if (offset + chunk + replaceLen > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n chunk << 1\n );\n offset += chunk;\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(replacement),\n replaceLen << 1\n );\n offset += replaceLen;\n prev = next + searchLen;\n }\n if (out) {\n let rest = thisLen - prev;\n if (offset + rest > outSize) {\n outSize <<= 1;\n out = changetype(__renew(changetype(out), outSize << 1));\n }\n if (rest) {\n memory.copy(\n changetype(out) + (offset << 1),\n changetype(this) + (prev << 1),\n rest << 1\n );\n }\n rest += offset;\n if (outSize > rest) {\n out = changetype(__renew(changetype(out), rest << 1));\n }\n return out;\n }\n return this;\n }\n\n slice(start: i32, end: i32 = i32.MAX_VALUE): String {\n let len = this.length;\n start = start < 0 ? max(start + len, 0) : min(start, len);\n end = end < 0 ? max(end + len, 0) : min(end, len);\n len = end - start;\n if (len <= 0) return changetype(\"\");\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n return out;\n }\n\n split(separator: String | null = null, limit: i32 = i32.MAX_VALUE): String[] {\n if (!limit) return changetype(__newArray(0, alignof(), idof>()));\n if (changetype(separator) == 0) return [ this ];\n let length: isize = this.length;\n let sepLen = changetype(separator).length;\n if (limit < 0) limit = i32.MAX_VALUE;\n if (!sepLen) {\n if (!length) return changetype(__newArray(0, alignof(), idof>()));\n // split by chars\n length = min(length, limit);\n let result = changetype(__newArray(length, alignof(), idof>()));\n // @ts-ignore: cast\n let resultStart = result.dataStart as usize;\n for (let i: isize = 0; i < length; ++i) {\n let charStr = changetype(__new(2, idof()));\n store(changetype(charStr), load(changetype(this) + (i << 1)));\n store(resultStart + (i << alignof()), changetype(charStr)); // result[i] = charStr\n __link(changetype(result), changetype(charStr), true);\n }\n return result;\n } else if (!length) {\n let result = changetype(__newArray(1, alignof(), idof>()));\n // @ts-ignore: cast\n store(result.dataStart as usize, changetype(\"\")); // static \"\"\n return result;\n }\n let result = changetype(__newArray(0, alignof(), idof>()));\n let end = 0, start = 0, i = 0;\n while (~(end = this.indexOf(changetype(separator), start))) {\n let len = end - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\"));\n }\n if (++i == limit) return result;\n start = end + sepLen;\n }\n if (!start) { // also means: loop above didn't do anything\n result.push(this);\n return result;\n }\n let len = length - start;\n if (len > 0) {\n let out = changetype(__new(len << 1, idof()));\n memory.copy(changetype(out), changetype(this) + (start << 1), len << 1);\n result.push(out);\n } else {\n result.push(changetype(\"\")); // static \"\"\n }\n return result;\n }\n\n toLowerCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 2 * 2, idof()));\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toLower8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // check special casing for lower table. It has one ently so instead lookup we just inline this.\n if (c == 0x0130) {\n // 0x0130 -> [0x0069, 0x0307]\n store(changetype(codes) + (j << 1), (0x0307 << 16) | 0x0069);\n ++j;\n } else if (c == 0x03A3) { // 'Σ'\n // Σ maps to σ but except at the end of a word where it maps to ς\n let sigma = 0x03C3; // σ\n if (len > 1 && isFinalSigma(changetype(this), i, len)) {\n sigma = 0x03C2; // ς\n }\n store(changetype(codes) + (j << 1), sigma);\n } else if (c - 0x24B6 <= 0x24CF - 0x24B6) {\n // Range 0x24B6 <= c <= 0x24CF not covered by casemap and require special early handling\n store(changetype(codes) + (j << 1), c + 26);\n } else {\n let code = casemap(c, 0) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toUpperCase(): String {\n let len = this.length;\n if (!len) return this;\n let codes = changetype(__new(len * 3 * 2, idof()));\n let specialsPtr = changetype(SPECIALS_UPPER);\n let specialsLen = SPECIALS_UPPER.length;\n let j: usize = 0;\n for (let i: usize = 0; i < len; ++i, ++j) {\n let c = load(changetype(this) + (i << 1));\n if (isAscii(c)) {\n store(changetype(codes) + (j << 1), toUpper8(c));\n } else {\n // check and read surrogate pair\n if ((c - 0xD7FF < 0xDC00 - 0xD7FF) && i < len - 1) {\n let c1 = load(changetype(this) + (i << 1), 2);\n if (c1 - 0xDBFF < 0xE000 - 0xDBFF) {\n let c0 = c;\n c = (((c & 0x03FF) << 10) | (c1 & 0x03FF)) + 0x10000;\n ++i;\n if (c >= 0x20000) {\n store(changetype(codes) + (j << 1), c0 | (c1 << 16));\n ++j;\n continue;\n }\n }\n }\n // Range 0x24D0 <= c <= 0x24E9 not covered by casemap and require special early handling\n if (c - 0x24D0 <= 0x24E9 - 0x24D0) {\n // monkey patch\n store(changetype(codes) + (j << 1), c - 26);\n } else {\n let index: usize = -1;\n // Fast range check. See first and last rows in specialsUpper table\n if (c - 0x00DF <= 0xFB17 - 0x00DF) {\n index = bsearch(c, specialsPtr, specialsLen);\n }\n if (~index) {\n // load next 3 code points from row with `index` offset for specialsUpper table\n let ab = load(specialsPtr + (index << 1), 2);\n let cc = load(specialsPtr + (index << 1), 6);\n store(changetype(codes) + (j << 1), ab, 0);\n store(changetype(codes) + (j << 1), cc, 4);\n j += 1 + usize(cc != 0);\n } else {\n let code = casemap(c, 1) & 0x1FFFFF;\n if (code < 0x10000) {\n store(changetype(codes) + (j << 1), code);\n } else {\n // store as surrogare pair\n code -= 0x10000;\n let lo = (code >>> 10) | 0xD800;\n let hi = (code & 0x03FF) | 0xDC00;\n store(changetype(codes) + (j << 1), lo | (hi << 16));\n ++j;\n }\n }\n }\n }\n }\n return changetype(__renew(changetype(codes), j << 1));\n }\n\n toString(): String {\n return this;\n }\n}\n\n// @ts-ignore: nolib\nexport type string = String;\n\nexport function parseInt(str: string, radix: i32 = 0): f64 {\n return strtol(str, radix);\n}\n\nexport function parseFloat(str: string): f64 {\n return strtod(str);\n}\n\n// Encoding helpers\nexport namespace String {\n\n export namespace UTF8 {\n\n export const enum ErrorMode {\n WTF8,\n REPLACE,\n ERROR\n }\n\n export function byteLength(str: string, nullTerminated: bool = false): i32 {\n let strOff = changetype(str);\n let strEnd = strOff + changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n let bufLen = i32(nullTerminated);\n while (strOff < strEnd) {\n let c1 = load(strOff);\n if (c1 < 128) {\n // @ts-ignore: cast\n if (nullTerminated & !c1) break;\n bufLen += 1;\n } else if (c1 < 2048) {\n bufLen += 2;\n } else {\n if ((c1 & 0xFC00) == 0xD800 && strOff + 2 < strEnd) {\n if ((load(strOff, 2) & 0xFC00) == 0xDC00) {\n bufLen += 4; strOff += 4;\n continue;\n }\n }\n bufLen += 3;\n }\n strOff += 2;\n }\n return bufLen;\n }\n\n export function encode(str: string, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): ArrayBuffer {\n let buf = changetype(__new(byteLength(str, nullTerminated), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf), nullTerminated, errorMode);\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize, nullTerminated: bool = false, errorMode: ErrorMode = ErrorMode.WTF8): usize {\n let strEnd = str + (len << 1);\n let bufOff = buf;\n while (str < strEnd) {\n let c1 = load(str);\n if (c1 < 128) {\n store(bufOff, c1);\n bufOff++;\n // @ts-ignore: cast\n if (nullTerminated & !c1) return bufOff - buf;\n } else if (c1 < 2048) {\n let b0 = c1 >> 6 | 192;\n let b1 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n bufOff += 2;\n } else {\n // D800: 11011 0 0000000000 Lead\n // DBFF: 11011 0 1111111111\n // DC00: 11011 1 0000000000 Trail\n // DFFF: 11011 1 1111111111\n // F800: 11111 0 0000000000 Mask\n // FC00: 11111 1 0000000000\n if ((c1 & 0xF800) == 0xD800) {\n if (c1 < 0xDC00 && str + 2 < strEnd) {\n let c2 = load(str, 2);\n if ((c2 & 0xFC00) == 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) | (c2 & 0x03FF);\n let b0 = c1 >> 18 | 240;\n let b1 = c1 >> 12 & 63 | 128;\n let b2 = c1 >> 6 & 63 | 128;\n let b3 = c1 & 63 | 128;\n store(bufOff, b3 << 24 | b2 << 16 | b1 << 8 | b0);\n bufOff += 4; str += 4;\n continue;\n }\n }\n if (errorMode != ErrorMode.WTF8) { // unlikely\n if (errorMode == ErrorMode.ERROR) throw new Error(E_UNPAIRED_SURROGATE);\n c1 = 0xFFFD;\n }\n }\n let b0 = c1 >> 12 | 224;\n let b1 = c1 >> 6 & 63 | 128;\n let b2 = c1 & 63 | 128;\n store(bufOff, b1 << 8 | b0);\n store(bufOff, b2, 2);\n bufOff += 3;\n }\n str += 2;\n }\n if (nullTerminated) {\n store(bufOff++, 0);\n }\n return bufOff - buf;\n }\n\n export function decode(buf: ArrayBuffer, nullTerminated: bool = false): String {\n return decodeUnsafe(changetype(buf), buf.byteLength, nullTerminated);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize, nullTerminated: bool = false): String {\n let bufOff = buf;\n let bufEnd = buf + len;\n assert(bufEnd >= bufOff); // guard wraparound\n let str = changetype(__new(len << 1, idof())); // max is one u16 char per u8 byte\n let strOff = changetype(str);\n while (bufOff < bufEnd) {\n let u0 = load(bufOff); ++bufOff;\n if (!(u0 & 128)) {\n // @ts-ignore: cast\n if (nullTerminated & !u0) break;\n store(strOff, u0);\n } else {\n if (bufEnd == bufOff) break;\n let u1 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 224) == 192) {\n store(strOff, (u0 & 31) << 6 | u1);\n } else {\n if (bufEnd == bufOff) break;\n let u2 = load(bufOff) & 63; ++bufOff;\n if ((u0 & 240) == 224) {\n u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n } else {\n if (bufEnd == bufOff) break;\n u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | load(bufOff) & 63;\n ++bufOff;\n }\n if (u0 < 0x10000) {\n store(strOff, u0);\n } else {\n u0 -= 0x10000;\n let lo = u0 >> 10 | 0xD800;\n let hi = (u0 & 0x03FF) | 0xDC00;\n store(strOff, lo | (hi << 16));\n strOff += 2;\n }\n }\n }\n strOff += 2;\n }\n return changetype(__renew(changetype(str), strOff - changetype(str)));\n }\n }\n\n export namespace UTF16 {\n\n export function byteLength(str: string): i32 {\n return changetype(changetype(str) - TOTAL_OVERHEAD).rtSize;\n }\n\n export function encode(str: string): ArrayBuffer {\n let buf = changetype(__new(byteLength(str), idof()));\n encodeUnsafe(changetype(str), str.length, changetype(buf));\n return buf;\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function encodeUnsafe(str: usize, len: i32, buf: usize): usize {\n let size = len << 1;\n memory.copy(buf, changetype(str), size);\n return size;\n }\n\n export function decode(buf: ArrayBuffer): String {\n return decodeUnsafe(changetype(buf), buf.byteLength);\n }\n\n // @ts-ignore: decorator\n @unsafe\n export function decodeUnsafe(buf: usize, len: usize): String {\n let str = changetype(__new(len &= ~1, idof()));\n memory.copy(changetype(str), buf, len);\n return str;\n }\n }\n}\n\nexport class TemplateStringsArray extends Array {\n readonly raw: string[];\n}\n","import { InstructionRun, ok, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// BRANCH_EQ_IMM\nexport const branch_eq_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] === b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE_IMM\nexport const branch_ne_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] !== b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U_IMM\nexport const branch_lt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] < b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_U_IMM\nexport const branch_le_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] <= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U_IMM\nexport const branch_ge_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] >= b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_U_IMM\nexport const branch_gt_u_imm: InstructionRun = (args, registers) => {\n const b = u64(u32SignExtend(args.b));\n if (registers[reg(args.a)] > b) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S_IMM\nexport const branch_lt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) < u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LE_S_IMM\nexport const branch_le_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) <= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S_IMM\nexport const branch_ge_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) >= u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GT_S_IMM\nexport const branch_gt_s_imm: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.a)]) > u32SignExtend(args.b)) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_EQ\nexport const branch_eq: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_NE\nexport const branch_ne: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== registers[reg(args.b)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_U\nexport const branch_lt_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] < registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_LT_S\nexport const branch_lt_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_U\nexport const branch_ge_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.b)] >= registers[reg(args.a)]) {\n return staticJump(args.c);\n }\n return ok();\n};\n\n// BRANCH_GE_S\nexport const branch_ge_s: InstructionRun = (args, registers) => {\n if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {\n return staticJump(args.c);\n }\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { branch_eq_imm } from \"./branch\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"branch_eq_imm\", () => {\n // when\n const args = new Args();\n args.a = 0;\n args.b = 0xfe;\n args.c = 0xdeadbeef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xfe;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = branch_eq_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.StaticJump, \"outcome\");\n assert.isEqual(ret.staticJump, 0xdeadbeef, \"staticJump\");\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// AND_IMM\nexport const and_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);\n return ok();\n};\n\n// XOR_IMM\nexport const xor_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);\n return ok();\n};\n\n// OR_IMM\nexport const or_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);\n return ok();\n};\n\n// AND\nexport const and: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];\n return ok();\n};\n\n// XOR\nexport const xor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];\n return ok();\n};\n\n// OR\nexport const or: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];\n return ok();\n};\n\n// AND_INV\nexport const and_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];\n return ok();\n};\n\n// OR_INV\nexport const or_inv: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] | ~registers[reg(args.a)];\n return ok();\n};\n\n// XNOR\nexport const xnor: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = ~(registers[reg(args.b)] ^ registers[reg(args.a)]);\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { and_inv, or_inv, xnor } from \"./logic\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"and_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = and_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_f000_0000_0000);\n return assert;\n }),\n test(\"or_inv\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0001;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = or_inv(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fff1);\n return assert;\n }),\n test(\"xnor\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x3;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x0000_0000_000f;\n regs[reg(args.b)] = 0xf000_0000_0000;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = xnor(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_0fff_ffff_fff0);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { mulUpperSigned, mulUpperSignedUnsigned, mulUpperUnsigned, reg, u32SignExtend } from \"./utils\";\n\n// ADD_IMM_32\nexport const add_imm_32: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const c = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(a + c));\n return ok();\n};\n\n// MUL_IMM_32\nexport const mul_imm_32: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = u32SignExtend(u32(registers[reg(args.a)] * args.c));\n return ok();\n};\n\n// NEG_ADD_IMM_32\nexport const neg_add_imm_32: InstructionRun = (args, registers) => {\n const sum = (u64(args.c) | 0x1_0000_0000) - registers[reg(args.a)];\n registers[reg(args.b)] = u32SignExtend(u32(sum));\n return ok();\n};\n\n// ADD_IMM\nexport const add_imm: InstructionRun = (args, registers) => {\n const sum: u64 = registers[reg(args.a)] + u32SignExtend(args.c);\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// MUL_IMM\nexport const mul_imm: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)] * u32SignExtend(args.c);\n return ok();\n};\n\n// NEG_ADD_IMM\nexport const neg_add_imm: InstructionRun = (args, registers) => {\n const sum = u32SignExtend(args.c) - registers[reg(args.a)];\n registers[reg(args.b)] = sum;\n return ok();\n};\n\n// ADD_32\nexport const add_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(a + b);\n return ok();\n};\n\n// SUB_32\nexport const sub_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.b)] + 2 ** 32 - u32(registers[reg(args.a)])));\n return ok();\n};\n\n// MUL_32\nexport const mul_32: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = u32SignExtend(u32(registers[reg(args.a)] * registers[reg(args.b)]));\n return ok();\n};\n\n// DIV_U_32\nexport const div_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n const b = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(b / a);\n }\n return ok();\n};\n\n// DIV_S_32\nexport const div_s_32: InstructionRun = (args, registers) => {\n const b = u32SignExtend(u32(registers[reg(args.b)]));\n const a = u32SignExtend(u32(registers[reg(args.a)]));\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U_32\nexport const rem_u_32: InstructionRun = (args, registers) => {\n const a = u32(registers[reg(args.a)]);\n const b = u32(registers[reg(args.b)]);\n if (a === 0) {\n registers[reg(args.c)] = u32SignExtend(b);\n } else {\n registers[reg(args.c)] = u32SignExtend(b % a);\n }\n return ok();\n};\n\n// REM_S_32\nexport const rem_s_32: InstructionRun = (args, registers) => {\n const b = i32(registers[reg(args.b)]);\n const a = i32(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = i64(b);\n } else if (a === -1 && b === i32.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = i64(b) % i64(a);\n }\n return ok();\n};\n\n// ADD_64\nexport const add_64: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] + registers[reg(args.b)];\n return ok();\n};\n\n// SUB\nexport const sub: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] - registers[reg(args.a)];\n return ok();\n};\n\n// MUL\nexport const mul: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.a)] * registers[reg(args.b)];\n return ok();\n};\n\n// DIV_U\nexport const div_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];\n }\n return ok();\n};\n\n// DIV_S\nexport const div_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = u64.MAX_VALUE;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = b;\n } else {\n registers[reg(args.c)] = b / a;\n }\n return ok();\n};\n\n// REM_U\nexport const rem_u: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n } else {\n registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];\n }\n return ok();\n};\n\n// REM_S\nexport const rem_s: InstructionRun = (args, registers) => {\n const b = i64(registers[reg(args.b)]);\n const a = i64(registers[reg(args.a)]);\n if (a === 0) {\n registers[reg(args.c)] = b;\n } else if (a === -1 && b === i64.MIN_VALUE) {\n registers[reg(args.c)] = 0;\n } else {\n registers[reg(args.c)] = b % a;\n }\n return ok();\n};\n\n// MUL_UPPER_S_S\nexport const mul_upper_s_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));\n return ok();\n};\n\n// MUL_UPPER_U_U\nexport const mul_upper_u_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);\n return ok();\n};\n\n// MUL_UPPER_S_U\nexport const mul_upper_s_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);\n return ok();\n};\n\n// MAX\nexport const max: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MAX_U\nexport const max_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a < b ? b : a;\n return ok();\n};\n\n// MIN\nexport const min: InstructionRun = (args, registers) => {\n const a = i64(registers[reg(args.a)]);\n const b = i64(registers[reg(args.b)]);\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n\n// MIN_U\nexport const min_u: InstructionRun = (args, registers) => {\n const a = registers[reg(args.a)];\n const b = registers[reg(args.b)];\n registers[reg(args.c)] = a > b ? b : a;\n return ok();\n};\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport * as math from \"./math\";\nimport { Outcome } from \"./outcome\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"max\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"max_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.max_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], -(2 ** 63));\n return assert;\n }),\n test(\"min_u\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = -(2 ** 63);\n regs[reg(args.b)] = 2;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.min_u(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 2);\n return assert;\n }),\n test(\"add_32\", () => {\n // when\n const args = Args.from(0x0, 0x1, 0x3);\n const regs = newRegisters();\n regs[reg(args.a)] = 2 ** 64 - 1;\n regs[reg(args.b)] = 2 ** 64 - 1;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = math.add_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_ffff_fffe);\n return assert;\n }),\n];\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// ROT_R_64_IMM\nexport const rot_r_64_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));\n return ok();\n};\n\n// ROT_R_64_IMM_ALT\nexport const rot_r_64_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32_IMM\nexport const rot_r_32_imm: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));\n return ok();\n};\n\n// ROT_R_32_IMM_ALT\nexport const rot_r_32_imm_alt: InstructionRun = (args, regs) => {\n regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_L_64\nexport const rot_l_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_L_32\nexport const rot_l_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\n// ROT_R_64\nexport const rot_r_64: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);\n return ok();\n};\n\n// ROT_R_32\nexport const rot_r_32: InstructionRun = (args, regs) => {\n regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));\n return ok();\n};\n\nexport namespace math {\n // @inline\n export function rot_r(v: u64, shift: u64): u64 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_r_32(v: u32, shift: u32): u32 {\n return rotr(v, shift);\n }\n // @inline\n export function rot_l(v: u64, shift: u64): u64 {\n return rotl(v, shift);\n }\n // @inline\n export function rot_l_32(v: u32, shift: u32): u32 {\n return rotl(v, shift);\n }\n}\n","import { Args } from \"../arguments\";\nimport { MemoryBuilder } from \"../memory\";\nimport { newRegisters } from \"../registers\";\nimport { Assert, Test, test } from \"../test\";\nimport { Outcome } from \"./outcome\";\nimport { rot_l_32, rot_l_64, rot_r_64_imm, rot_r_64_imm_alt } from \"./rot\";\nimport { reg } from \"./utils\";\n\nexport const TESTS: Test[] = [\n test(\"rot_r_64_imm\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xef00_0000_00de_adbe);\n return assert;\n }),\n test(\"rot_r_64_imm_alt\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0xdead_beef;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_r_64_imm_alt(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.b)], 0xefff_ffff_ffde_adbe);\n return assert;\n }),\n test(\"rot_l_64\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_64(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0x0000_00de_adbe_ef00);\n return assert;\n }),\n test(\"rot_l_32\", () => {\n // when\n const args = new Args();\n args.a = 0x0;\n args.b = 0x1;\n args.c = 0x8;\n const regs = newRegisters();\n regs[reg(args.a)] = 0x8;\n regs[reg(args.b)] = 0xdead_beef;\n\n const memo = new MemoryBuilder().build();\n\n // when\n const ret = rot_l_32(args, regs, memo);\n\n // then\n const assert = new Assert();\n assert.isEqual(ret.outcome, Outcome.Ok, \"outcome\");\n assert.isEqual(regs[reg(args.c)], 0xffff_ffff_adbe_efde);\n return assert;\n }),\n];\n","import { MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, RESERVED_MEMORY, RESERVED_PAGES } from \"./memory-page\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"Show fail when accessing any of the initial 16 pages\", () => {\n const mem = new MemoryBuilder().build();\n\n const a = mem.getI8(0);\n const b = mem.getU64(RESERVED_MEMORY - 1);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, true, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.fault.fault, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 61440);\n return assert;\n }),\n test(\"Show fail on missing page or invalid access\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Read, RESERVED_MEMORY, new Uint8Array(10));\n const mem = builder.build();\n\n const a = mem.getU64(RESERVED_MEMORY);\n const b = mem.getU8((RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT);\n const c = mem.setU8(RESERVED_MEMORY, 12);\n const d = mem.getU8(RESERVED_MEMORY);\n\n const assert = new Assert();\n assert.isEqual(a.fault.isFault, false, \"a.fault\");\n assert.isEqual(a.fault.isAccess, false, \"a.access\");\n assert.isEqual(a.ok, 0);\n assert.isEqual(b.fault.isFault, true, \"b.fault\");\n assert.isEqual(b.fault.isAccess, false, \"b.access\");\n assert.isEqual(b.fault.fault, 69632);\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, true, \"c.access\");\n assert.isEqual(c.fault, 65536);\n assert.isEqual(d.ok, 0);\n return assert;\n }),\n test(\"should read and write across pages\", () => {\n const builder = new MemoryBuilder();\n builder.setData(Access.Write, RESERVED_MEMORY, new Uint8Array(1));\n builder.setData(Access.Write, (RESERVED_PAGES + 1) << PAGE_SIZE_SHIFT, new Uint8Array(1));\n const mem = builder.build();\n\n const out = new Uint8Array(16);\n const data = new Uint8Array(out.length);\n data.set([0xde, 0xad, 0xbe, 0xef], 0);\n\n const a = mem.bytesWrite(RESERVED_MEMORY + PAGE_SIZE - 10, data);\n const b = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE - 9, out);\n const c = mem.bytesRead(RESERVED_MEMORY + PAGE_SIZE * 2, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(a.isAccess, false, \"a.access\");\n assert.isEqual(a.fault, 0, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(b.isAccess, false, \"b.access\");\n assert.isEqual(b.fault, 0, \"b.fault\");\n assert.isEqual(c.isFault, true, \"c.fault\");\n assert.isEqual(c.isAccess, false, \"c.access\");\n assert.isEqual(out.toString(), \"173,190,239,0,0,0,0,0,0,0,0,0,0,0,0,0\");\n assert.isEqual(data.toString(), \"222,173,190,239,0,0,0,0,0,0,0,0,0,0,0,0\");\n return assert;\n }),\n test(\"should allow 0-bytes reads and writes everywhere\", () => {\n const mem = new MemoryBuilder().setData(Access.Read, RESERVED_MEMORY, new Uint8Array(0)).build();\n\n const out = new Uint8Array(0);\n\n // reserved pages\n const a = mem.bytesRead(0, out);\n const b = mem.bytesWrite(0, out);\n\n // not allocated\n const c = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n const d = mem.bytesRead(RESERVED_MEMORY + RESERVED_MEMORY, out);\n\n // readable page\n const e = mem.bytesWrite(RESERVED_MEMORY, out);\n\n const assert = new Assert();\n assert.isEqual(a.isFault, false, \"a.fault\");\n assert.isEqual(b.isFault, false, \"b.fault\");\n assert.isEqual(c.isFault, false, \"c.fault\");\n assert.isEqual(d.isFault, false, \"d.fault\");\n assert.isEqual(e.isFault, false, \"e.fault\");\n return assert;\n }),\n];\n","export function REVERSE(ptr: usize, len: usize): void {\n if (len > 1) {\n let\n i: usize = 0,\n tail: usize,\n hlen: usize = len >> 1;\n\n if (ASC_SHRINK_LEVEL < 1) {\n if (sizeof() == 1) {\n // TODO: Decide later: Does we need this fast path cases?\n //\n // if (len == 4) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n // if (len == 8) {\n // store(ptr, bswap(load(ptr)));\n // return;\n // }\n tail = len - 8;\n while (i + 7 < hlen) {\n let front = ptr + i;\n let back = ptr + tail - i;\n let temp = bswap(load(front));\n store(front, bswap(load(back)));\n store(back, temp);\n i += 8;\n }\n }\n\n if (sizeof() == 2) {\n tail = len - 2;\n while (i + 1 < hlen) {\n let front = ptr + (i << 1);\n let back = ptr + (tail - i << 1);\n let temp = rotr(load(back), 16);\n store(back, rotr(load(front), 16));\n store(front, temp);\n i += 2;\n }\n }\n }\n\n tail = len - 1;\n while (i < hlen) {\n let front = ptr + (i << alignof());\n let back = ptr + (tail - i << alignof());\n let temp = load(front);\n store(front, load(back));\n store(back, temp);\n i++;\n }\n }\n}\n\nexport function FILL(\n ptr: usize,\n len: usize,\n value: T,\n start: isize,\n end: isize\n): void {\n start = start < 0 ? max(len + start, 0) : min(start, len);\n end = end < 0 ? max(len + end, 0) : min(end, len);\n\n if (sizeof() == 1) {\n if (start < end) {\n memory.fill(\n ptr + start,\n u8(value),\n (end - start)\n );\n }\n } else {\n if (ASC_SHRINK_LEVEL <= 1) {\n if (isInteger()) {\n // @ts-ignore\n if (value == 0 | value == -1) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n u8(value),\n (end - start) << alignof()\n );\n }\n return;\n }\n } else if (isFloat()) {\n // for floating non-negative zeros we can use fast memory.fill\n if ((sizeof() == 4 && reinterpret(f32(value)) == 0) ||\n (sizeof() == 8 && reinterpret(f64(value)) == 0)) {\n if (start < end) {\n memory.fill(\n ptr + (start << alignof()),\n 0,\n (end - start) << alignof()\n );\n }\n return;\n }\n }\n }\n for (; start < end; ++start) {\n store(ptr + (start << alignof()), value);\n }\n }\n}\n","import {\n console as binding\n} from \"./bindings/dom\";\n\nexport namespace console {\n\n export function assert(condition: T, message: string = \"\"): void {\n binding.assert(!!condition, message);\n }\n\n export function log(message: string = \"\"): void {\n binding.log(message);\n }\n\n export function debug(message: string = \"\"): void {\n binding.debug(message);\n }\n\n export function info(message: string = \"\"): void {\n binding.info(message);\n }\n\n export function warn(message: string = \"\"): void {\n binding.warn(message);\n }\n\n export function error(message: string = \"\"): void {\n binding.error(message);\n }\n\n export function time(label: string = \"default\"): void {\n binding.time(label);\n }\n\n export function timeLog(label: string = \"default\"): void {\n binding.timeLog(label);\n }\n\n export function timeEnd(label: string = \"default\"): void {\n binding.timeEnd(label);\n }\n}\n","import { dJump, InstructionRun, staticJump } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// JUMP\nexport const jump: InstructionRun = (args) => staticJump(args.a);\n\n// JUMP_IND\nexport const jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n return dJump(address);\n};\n\n// LOAD_IMM_JUMP\nexport const load_imm_jump: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return staticJump(args.c);\n};\n\n// LOAD_IMM_JUMP_IND\nexport const load_imm_jump_ind: InstructionRun = (args, registers) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.d));\n registers[reg(args.b)] = u32SignExtend(args.c);\n return dJump(address);\n};\n","import { hostCall, InstructionRun, ok, okOrFault, panic } from \"./outcome\";\nimport { reg } from \"./utils\";\n\n// INVALID\nexport const INVALID: InstructionRun = () => panic();\n\n// TRAP\nexport const trap: InstructionRun = () => panic();\n\n// FALLTHROUGH\nexport const fallthrough: InstructionRun = () => ok();\n\n// ECALLI\nexport const ecalli: InstructionRun = (args) => hostCall(args.a);\n\n// SBRK\nexport const sbrk: InstructionRun = (args, registers, memory) => {\n const res = memory.sbrk(u32(registers[reg(args.a)]));\n // out of memory\n if (res.fault.isFault) {\n return okOrFault(res.fault);\n }\n registers[reg(args.b)] = res.ok;\n return ok();\n};\n","import { InstructionRun, ok, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// LOAD_IMM_64\nexport const load_imm_64: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u64(args.b) + (u64(args.c) << 32);\n return ok();\n};\n\n// LOAD_IMM\nexport const load_imm: InstructionRun = (args, registers) => {\n registers[reg(args.a)] = u32SignExtend(args.b);\n return ok();\n};\n\n// LOAD_U8\nexport const load_u8: InstructionRun = (args, registers, memory) => {\n const result = memory.getU8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I8\nexport const load_i8: InstructionRun = (args, registers, memory) => {\n const result = memory.getI8(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U16\nexport const load_u16: InstructionRun = (args, registers, memory) => {\n const result = memory.getU16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I16\nexport const load_i16: InstructionRun = (args, registers, memory) => {\n const result = memory.getI16(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U32\nexport const load_u32: InstructionRun = (args, registers, memory) => {\n const result = memory.getU32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_I32\nexport const load_i32: InstructionRun = (args, registers, memory) => {\n const result = memory.getI32(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_U64\nexport const load_u64: InstructionRun = (args, registers, memory) => {\n const result = memory.getU64(args.b);\n if (!result.fault.isFault) {\n registers[reg(args.a)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U8\nexport const load_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I8\nexport const load_ind_i8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI8(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U16\nexport const load_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I16\nexport const load_ind_i16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI16(address);\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U32\nexport const load_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_I32\nexport const load_ind_i32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getI32(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n\n// LOAD_IND_U64\nexport const load_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const result = memory.getU64(u32(address));\n if (!result.fault.isFault) {\n registers[reg(args.b)] = result.ok;\n }\n return okOrFault(result.fault);\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// MOVE_REG\nexport const move_reg: InstructionRun = (args, registers) => {\n registers[reg(args.b)] = registers[reg(args.a)];\n return ok();\n};\n\n// CMOV_IZ_IMM\nexport const cmov_iz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_NZ_IMM\nexport const cmov_nz_imm: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.b)] = u32SignExtend(args.c);\n }\n return ok();\n};\n\n// CMOV_IZ\nexport const cmov_iz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] === 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n\n// CMOV_NZ\nexport const cmov_nz: InstructionRun = (args, registers) => {\n if (registers[reg(args.a)] !== 0) {\n registers[reg(args.c)] = registers[reg(args.b)];\n }\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// SET_LT_U_IMM\nexport const set_lt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S_IMM\nexport const set_lt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) < u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_U_IMM\nexport const set_gt_u_imm: InstructionRun = (args, registers) => {\n const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_GT_S_IMM\nexport const set_gt_s_imm: InstructionRun = (args, registers) => {\n const cond = i64(registers[reg(args.a)]) > u32SignExtend(args.c);\n registers[reg(args.b)] = cond ? 1 : 0;\n return ok();\n};\n\n// SET_LT_U\nexport const set_lt_u: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? 1 : 0;\n return ok();\n};\n\n// SET_LT_S\nexport const set_lt_s: InstructionRun = (args, registers) => {\n registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? 1 : 0;\n return ok();\n};\n","import { InstructionRun, ok } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\nconst MAX_SHIFT_64 = 64;\nconst MAX_SHIFT_32 = 32;\n\n// SHLO_L_IMM_32\nexport const shlo_l_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_IMM_32\nexport const shlo_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32(registers[reg(args.a)]);\n registers[reg(args.b)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_32\nexport const shar_r_imm_32: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_32);\n const value = u32SignExtend(u32(registers[reg(args.a)]));\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT_32\nexport const shlo_l_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c << shift);\n return ok();\n};\n\n// SHLO_R_IMM_ALT_32\nexport const shlo_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n registers[reg(args.b)] = u32SignExtend(args.c >>> shift);\n return ok();\n};\n\n// SHAR_R_IMM_ALT_32\nexport const shar_r_imm_alt_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const imm = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(imm >> shift));\n return ok();\n};\n\n// SHLO_L_IMM\nexport const shlo_l_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] << shift;\n return ok();\n};\n\n// SHLO_R_IMM\nexport const shlo_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n registers[reg(args.b)] = registers[reg(args.a)] >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM\nexport const shar_r_imm: InstructionRun = (args, registers) => {\n const shift = u32(args.c % MAX_SHIFT_64);\n const value = i64(registers[reg(args.a)]);\n registers[reg(args.b)] = value >> shift;\n return ok();\n};\n\n// SHLO_L_IMM_ALT\nexport const shlo_l_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) << shift;\n return ok();\n};\n\n// SHLO_R_IMM_ALT\nexport const shlo_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.b)] = u32SignExtend(args.c) >>> shift;\n return ok();\n};\n\n// SHAR_R_IMM_ALT\nexport const shar_r_imm_alt: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n const value = u32SignExtend(args.c);\n registers[reg(args.b)] = u32SignExtend(u32(value >> shift));\n return ok();\n};\n\n// SHLO_L_32\nexport const shlo_l_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value << shift);\n return ok();\n};\n\n// SHLO_R_32\nexport const shlo_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const value = u32(registers[reg(args.b)]);\n registers[reg(args.c)] = u32SignExtend(value >>> shift);\n return ok();\n};\n\n// SHAR_R_32\nexport const shar_r_32: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_32);\n const regValue = u32SignExtend(u32(registers[reg(args.b)]));\n registers[reg(args.c)] = u32SignExtend(u32(regValue >> shift));\n return ok();\n};\n\n// SHLO_L\nexport const shlo_l: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] << shift;\n return ok();\n};\n\n// SHLO_R\nexport const shlo_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = registers[reg(args.b)] >>> shift;\n return ok();\n};\n\n// SHAR_R\nexport const shar_r: InstructionRun = (args, registers) => {\n const shift = u32(registers[reg(args.a)] % MAX_SHIFT_64);\n registers[reg(args.c)] = i64(registers[reg(args.b)]) >> shift;\n return ok();\n};\n","import { InstructionRun, okOrFault } from \"./outcome\";\nimport { reg, u32SignExtend } from \"./utils\";\n\n// STORE_IMM_U8\nexport const store_imm_u8: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU8(address, (args.b & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U16\nexport const store_imm_u16: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU16(address, (args.b & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U32\nexport const store_imm_u32: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU32(address, args.b);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_U64\nexport const store_imm_u64: InstructionRun = (args, _registers, memory) => {\n const address = args.a;\n const pageFault = memory.setU64(address, u32SignExtend(args.b));\n return okOrFault(pageFault);\n};\n\n// STORE_U8\nexport const store_u8: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU8(args.b, (registers[reg(args.a)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_U16\nexport const store_u16: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU16(args.b, (registers[reg(args.a)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_U32\nexport const store_u32: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU32(args.b, u32(registers[reg(args.a)]));\n return okOrFault(fault);\n};\n\n// STORE_U64\nexport const store_u64: InstructionRun = (args, registers, memory) => {\n const fault = memory.setU64(args.b, registers[reg(args.a)]);\n return okOrFault(fault);\n};\n\n// STORE_IMM_IND_U8\nexport const store_imm_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU8(address, (args.c & 0xff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U16\nexport const store_imm_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU16(address, (args.c & 0xff_ff));\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U32\nexport const store_imm_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU32(address, args.c);\n return okOrFault(pageFault);\n};\n\n// STORE_IMM_IND_U64\nexport const store_imm_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.b));\n const pageFault = memory.setU64(address, u32SignExtend(args.c));\n return okOrFault(pageFault);\n};\n\n// STORE_IND_U8\nexport const store_ind_u8: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU8(address, (registers[reg(args.b)] & 0xff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U16\nexport const store_ind_u16: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU16(address, (registers[reg(args.b)] & 0xff_ff));\n return okOrFault(fault);\n};\n\n// STORE_IND_U32\nexport const store_ind_u32: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU32(address, u32(registers[reg(args.b)]));\n return okOrFault(fault);\n};\n\n// STORE_IND_U64\nexport const store_ind_u64: InstructionRun = (args, registers, memory) => {\n const address = u32(registers[reg(args.a)] + u32SignExtend(args.c));\n const fault = memory.setU64(address, registers[reg(args.b)]);\n return okOrFault(fault);\n};\n","import * as bit from \"./instructions/bit\";\nimport * as branch from \"./instructions/branch\";\nimport * as jump from \"./instructions/jump\";\nimport * as load from \"./instructions/load\";\nimport * as logic from \"./instructions/logic\";\nimport * as math from \"./instructions/math\";\nimport { ecalli, fallthrough, INVALID, sbrk, trap } from \"./instructions/misc\";\nimport * as mov from \"./instructions/mov\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport * as rot from \"./instructions/rot\";\nimport * as set from \"./instructions/set\";\nimport * as shift from \"./instructions/shift\";\nimport * as store from \"./instructions/store\";\n\nexport const RUN: InstructionRun[] = [\n /* 000 */ trap,\n /* 001 */ fallthrough,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 010 */ ecalli,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 020 */ load.load_imm_64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 030 */ store.store_imm_u8,\n /* 031 */ store.store_imm_u16,\n /* 032 */ store.store_imm_u32,\n /* 033 */ store.store_imm_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 040 */ jump.jump,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 050 */ jump.jump_ind,\n /* 051 */ load.load_imm,\n /* 052 */ load.load_u8,\n /* 053 */ load.load_i8,\n /* 054 */ load.load_u16,\n /* 055 */ load.load_i16,\n /* 056 */ load.load_u32,\n /* 057 */ load.load_i32,\n /* 058 */ load.load_u64,\n /* 059 */ store.store_u8,\n\n /* 060 */ store.store_u16,\n /* 061 */ store.store_u32,\n /* 062 */ store.store_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 070 */ store.store_imm_ind_u8,\n /* 071 */ store.store_imm_ind_u16,\n /* 072 */ store.store_imm_ind_u32,\n /* 073 */ store.store_imm_ind_u64,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 080 */ jump.load_imm_jump,\n /* 081 */ branch.branch_eq_imm,\n /* 082 */ branch.branch_ne_imm,\n /* 083 */ branch.branch_lt_u_imm,\n /* 084 */ branch.branch_le_u_imm,\n /* 085 */ branch.branch_ge_u_imm,\n /* 086 */ branch.branch_gt_u_imm,\n /* 087 */ branch.branch_lt_s_imm,\n /* 088 */ branch.branch_le_s_imm,\n /* 089 */ branch.branch_ge_s_imm,\n\n /* 090 */ branch.branch_gt_s_imm,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 100 */ mov.move_reg,\n /* 101 */ sbrk,\n /* 102 */ bit.count_set_bits_64,\n /* 103 */ bit.count_set_bits_32,\n /* 104 */ bit.leading_zero_bits_64,\n /* 105 */ bit.leading_zero_bits_32,\n /* 106 */ bit.trailing_zero_bits_64,\n /* 107 */ bit.trailing_zero_bits_32,\n /* 108 */ bit.sign_extend_8,\n /* 109 */ bit.sign_extend_16,\n\n /* 110 */ bit.zero_extend_16,\n /* 111 */ bit.reverse_bytes,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 120 */ store.store_ind_u8,\n /* 121 */ store.store_ind_u16,\n /* 122 */ store.store_ind_u32,\n /* 123 */ store.store_ind_u64,\n /* 124 */ load.load_ind_u8,\n /* 125 */ load.load_ind_i8,\n /* 126 */ load.load_ind_u16,\n /* 127 */ load.load_ind_i16,\n /* 128 */ load.load_ind_u32,\n /* 129 */ load.load_ind_i32,\n\n /* 130 */ load.load_ind_u64,\n /* 131 */ math.add_imm_32,\n /* 132 */ logic.and_imm,\n /* 133 */ logic.xor_imm,\n /* 134 */ logic.or_imm,\n /* 135 */ math.mul_imm_32,\n /* 136 */ set.set_lt_u_imm,\n /* 137 */ set.set_lt_s_imm,\n /* 138 */ shift.shlo_l_imm_32,\n /* 139 */ shift.shlo_r_imm_32,\n\n /* 140 */ shift.shar_r_imm_32,\n /* 141 */ math.neg_add_imm_32,\n /* 142 */ set.set_gt_u_imm,\n /* 143 */ set.set_gt_s_imm,\n /* 144 */ shift.shlo_l_imm_alt_32,\n /* 145 */ shift.shlo_r_imm_alt_32,\n /* 146 */ shift.shar_r_imm_alt_32,\n /* 147 */ mov.cmov_iz_imm,\n /* 148 */ mov.cmov_nz_imm,\n /* 149 */ math.add_imm,\n\n /* 150 */ math.mul_imm,\n /* 151 */ shift.shlo_l_imm,\n /* 152 */ shift.shlo_r_imm,\n /* 153 */ shift.shar_r_imm,\n /* 154 */ math.neg_add_imm,\n /* 155 */ shift.shlo_l_imm_alt,\n /* 156 */ shift.shlo_r_imm_alt,\n /* 157 */ shift.shar_r_imm_alt,\n /* 158 */ rot.rot_r_64_imm,\n /* 159 */ rot.rot_r_64_imm_alt,\n\n /* 160 */ rot.rot_r_32_imm,\n /* 161 */ rot.rot_r_32_imm_alt,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 170 */ branch.branch_eq,\n /* 171 */ branch.branch_ne,\n /* 172 */ branch.branch_lt_u,\n /* 173 */ branch.branch_lt_s,\n /* 174 */ branch.branch_ge_u,\n /* 175 */ branch.branch_ge_s,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 180 */ jump.load_imm_jump_ind,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n INVALID,\n\n /* 190 */ math.add_32,\n /* 191 */ math.sub_32,\n /* 192 */ math.mul_32,\n /* 193 */ math.div_u_32,\n /* 194 */ math.div_s_32,\n /* 195 */ math.rem_u_32,\n /* 196 */ math.rem_s_32,\n /* 197 */ shift.shlo_l_32,\n /* 198 */ shift.shlo_r_32,\n /* 199 */ shift.shar_r_32,\n\n /* 200 */ math.add_64,\n /* 201 */ math.sub,\n /* 202 */ math.mul,\n /* 203 */ math.div_u,\n /* 204 */ math.div_s,\n /* 205 */ math.rem_u,\n /* 206 */ math.rem_s,\n /* 207 */ shift.shlo_l,\n /* 208 */ shift.shlo_r,\n /* 209 */ shift.shar_r,\n\n /* 210 */ logic.and,\n /* 211 */ logic.xor,\n /* 212 */ logic.or,\n /* 213 */ math.mul_upper_s_s,\n /* 214 */ math.mul_upper_u_u,\n /* 215 */ math.mul_upper_s_u,\n /* 216 */ set.set_lt_u,\n /* 217 */ set.set_lt_s,\n /* 218 */ mov.cmov_iz,\n /* 219 */ mov.cmov_nz,\n\n /* 220 */ rot.rot_l_64,\n /* 221 */ rot.rot_l_32,\n /* 222 */ rot.rot_r_64,\n /* 223 */ rot.rot_r_32,\n /* 224 */ logic.and_inv,\n /* 225 */ logic.or_inv,\n /* 226 */ logic.xnor,\n /* 227 */ math.max,\n /* 228 */ math.max_u,\n /* 229 */ math.min,\n /* 230 */ math.min_u,\n];\n","const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];\n\nconst variableLength = (firstByte: u8): u8 => {\n const len = MASKS.length;\n for (let i: u8 = 0; i < len; i++) {\n if (firstByte >= MASKS[i]) {\n return 8 - i;\n }\n }\n return 0;\n};\n\nexport class Decoder {\n constructor(\n private readonly source: Uint8Array,\n private offset: i32 = 0,\n ) {}\n\n isExhausted(): boolean {\n return this.offset >= this.source.length;\n }\n\n private ensureBytes(need: u32): void {\n if (this.offset + need > this.source.length) {\n throw new Error(`Not enough bytes left. Need: ${need}, left: ${this.source.length - this.offset}`);\n }\n }\n\n finish(): void {\n if (!this.isExhausted()) {\n throw new Error(`Expecting to use all bytes from the decoder. Left: ${this.source.length - this.offset}`);\n }\n }\n\n varU32(): u32 {\n this.ensureBytes(1);\n const v = decodeVarU32(this.source.subarray(this.offset));\n this.offset += v.offset;\n return v.value;\n }\n\n u8(): u8 {\n this.ensureBytes(1);\n const v = this.source[this.offset];\n this.offset += 1;\n return v;\n }\n\n u16(): u16 {\n this.ensureBytes(2);\n let v: u16 = this.source[this.offset];\n v |= u16(this.source[this.offset + 1]) << 8;\n this.offset += 2;\n return v;\n }\n\n u24(): u32 {\n this.ensureBytes(3);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n this.offset += 3;\n return v;\n }\n\n u32(): u32 {\n this.ensureBytes(4);\n let v: u32 = this.source[this.offset];\n v |= u32(this.source[this.offset + 1]) << 8;\n v |= u32(this.source[this.offset + 2]) << 16;\n v |= u32(this.source[this.offset + 3]) << 24;\n this.offset += 4;\n return v;\n }\n\n bytes(len: i32): Uint8Array {\n this.ensureBytes(len);\n const v = this.source.subarray(this.offset, this.offset + len);\n this.offset += len;\n return v;\n }\n\n /** Read remaining bytes into Uint8Array */\n remainingBytes(): Uint8Array {\n const v = this.source.subarray(this.offset);\n this.offset += v.length;\n return v;\n }\n}\n\n// @unmanaged\nexport class ValOffset {\n constructor(\n public readonly value: T,\n public readonly offset: i32,\n ) {}\n}\n\n/** Read variable-length u32 and return number of bytes read. */\nexport function decodeVarU32(data: Uint8Array): ValOffset {\n const length = i32(variableLength(data[0]));\n const first = u32(data[0]);\n if (length === 0) {\n return new ValOffset(first, 1);\n }\n\n if (data.length < length) {\n throw new Error(`Not enough bytes to decode 'varU32'. Need ${length}, got: ${data.length}`);\n }\n\n const msb = (first + 2 ** (8 - length) - 2 ** 8) << (length * 8);\n let number: i32 = 0;\n for (let i = length - 1; i >= 0; i--) {\n number = (number << 8) + data[1 + i];\n }\n number += msb;\n\n return new ValOffset(number, 1 + length);\n}\n\nexport function encodeVarU32(v: u64): Uint8Array {\n if (v === 0) {\n return new Uint8Array(1);\n }\n\n // handle the biggest case\n let maxEncoded = u64(2 ** (7 * 8));\n if (v >= maxEncoded) {\n const dest = new Uint8Array(9);\n dest[0] = 0xff;\n const dataView = new DataView(dest.buffer);\n dataView.setUint64(1, v, true);\n return dest;\n }\n\n // let's look for the correct range\n let minEncoded = maxEncoded >> 7;\n for (let l = 7; l >= 0; l -= 1) {\n if (v >= minEncoded) {\n const dest = new Uint8Array(l + 1);\n\n // encode the first byte\n const maxVal = 2 ** (8 * l);\n const byte = 2 ** 8 - 2 ** (8 - l) + v / maxVal;\n dest[0] = u8(byte);\n\n // now encode the rest of bytes of len `l`\n let rest = v % maxVal;\n for (let i = 1; i < 1 + l; i += 1) {\n dest[i] = u8(rest);\n rest >>= 8;\n }\n return dest;\n }\n // move one power down\n maxEncoded = minEncoded;\n minEncoded >>= 7;\n }\n\n throw new Error(`Unhandled number encoding: ${v}`);\n}\n","import { Arguments } from \"./arguments\";\nimport { Gas } from \"./gas\";\n\n@unmanaged\nexport class Instruction {\n namePtr: usize = 0;\n kind: Arguments = Arguments.Zero;\n gas: Gas = 0;\n isTerminating: boolean = false;\n}\n\nfunction instruction(name: string, kind: Arguments, gas: Gas, isTerminating: boolean = false): Instruction {\n const i = new Instruction();\n i.namePtr = changetype(name);\n i.kind = kind;\n i.gas = gas;\n i.isTerminating = isTerminating;\n return i;\n}\n\nexport const MISSING_INSTRUCTION = instruction(\"INVALID\", Arguments.Zero, 1, false);\n\nexport const SBRK = instruction(\"SBRK\", Arguments.TwoReg, 1);\n\nexport const INSTRUCTIONS: Instruction[] = [\n /* 000 */ instruction(\"TRAP\", Arguments.Zero, 1, true),\n /* 001 */ instruction(\"FALLTHROUGH\", Arguments.Zero, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 010 */ instruction(\"ECALLI\", Arguments.OneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 020 */ instruction(\"LOAD_IMM_64\", Arguments.OneRegOneExtImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 030 */ instruction(\"STORE_IMM_U8\", Arguments.TwoImm, 1),\n /* 031 */ instruction(\"STORE_IMM_U16\", Arguments.TwoImm, 1),\n /* 032 */ instruction(\"STORE_IMM_U32\", Arguments.TwoImm, 1),\n /* 033 */ instruction(\"STORE_IMM_U64\", Arguments.TwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 040 */ instruction(\"JUMP\", Arguments.OneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 050 */ instruction(\"JUMP_IND\", Arguments.OneRegOneImm, 1, true),\n /* 051 */ instruction(\"LOAD_IMM\", Arguments.OneRegOneImm, 1),\n /* 052 */ instruction(\"LOAD_U8\", Arguments.OneRegOneImm, 1),\n /* 053 */ instruction(\"LOAD_I8\", Arguments.OneRegOneImm, 1),\n /* 054 */ instruction(\"LOAD_U16\", Arguments.OneRegOneImm, 1),\n /* 055 */ instruction(\"LOAD_I16\", Arguments.OneRegOneImm, 1),\n /* 056 */ instruction(\"LOAD_U32\", Arguments.OneRegOneImm, 1),\n /* 057 */ instruction(\"LOAD_I32\", Arguments.OneRegOneImm, 1),\n /* 058 */ instruction(\"LOAD_U64\", Arguments.OneRegOneImm, 1),\n /* 059 */ instruction(\"STORE_U8\", Arguments.OneRegOneImm, 1),\n\n /* 060 */ instruction(\"STORE_U16\", Arguments.OneRegOneImm, 1),\n /* 061 */ instruction(\"STORE_U32\", Arguments.OneRegOneImm, 1),\n /* 062 */ instruction(\"STORE_U64\", Arguments.OneRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 070 */ instruction(\"STORE_IMM_IND_U8\", Arguments.OneRegTwoImm, 1),\n /* 071 */ instruction(\"STORE_IMM_IND_U16\", Arguments.OneRegTwoImm, 1),\n /* 072 */ instruction(\"STORE_IMM_IND_U32\", Arguments.OneRegTwoImm, 1),\n /* 073 */ instruction(\"STORE_IMM_IND_U64\", Arguments.OneRegTwoImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 080 */ instruction(\"LOAD_IMM_JUMP\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 081 */ instruction(\"BRANCH_EQ_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 082 */ instruction(\"BRANCH_NE_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 083 */ instruction(\"BRANCH_LT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 084 */ instruction(\"BRANCH_LE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 085 */ instruction(\"BRANCH_GE_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 086 */ instruction(\"BRANCH_GT_U_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 087 */ instruction(\"BRANCH_LT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 088 */ instruction(\"BRANCH_LE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n /* 089 */ instruction(\"BRANCH_GE_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n\n /* 090 */ instruction(\"BRANCH_GT_S_IMM\", Arguments.OneRegOneImmOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 100 */ instruction(\"MOVE_REG\", Arguments.TwoReg, 1),\n /* 101 */ SBRK,\n /* 102 */ instruction(\"COUNT_SET_BITS_64\", Arguments.TwoReg, 1),\n /* 103 */ instruction(\"COUNT_SET_BITS_32\", Arguments.TwoReg, 1),\n /* 104 */ instruction(\"LEADING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 105 */ instruction(\"LEADING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 106 */ instruction(\"TRAILING_ZERO_BITS_64\", Arguments.TwoReg, 1),\n /* 107 */ instruction(\"TRAILING_ZERO_BITS_32\", Arguments.TwoReg, 1),\n /* 108 */ instruction(\"SIGN_EXTEND_8\", Arguments.TwoReg, 1),\n /* 109 */ instruction(\"SIGN_EXTEND_16\", Arguments.TwoReg, 1),\n\n /* 110 */ instruction(\"ZERO_EXTEND_16\", Arguments.TwoReg, 1),\n /* 111 */ instruction(\"REVERSE_BYTES\", Arguments.TwoReg, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 120 */ instruction(\"STORE_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 121 */ instruction(\"STORE_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 122 */ instruction(\"STORE_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 123 */ instruction(\"STORE_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 124 */ instruction(\"LOAD_IND_U8\", Arguments.TwoRegOneImm, 1),\n /* 125 */ instruction(\"LOAD_IND_I8\", Arguments.TwoRegOneImm, 1),\n /* 126 */ instruction(\"LOAD_IND_U16\", Arguments.TwoRegOneImm, 1),\n /* 127 */ instruction(\"LOAD_IND_I16\", Arguments.TwoRegOneImm, 1),\n /* 128 */ instruction(\"LOAD_IND_U32\", Arguments.TwoRegOneImm, 1),\n /* 129 */ instruction(\"LOAD_IND_I32\", Arguments.TwoRegOneImm, 1),\n\n /* 130 */ instruction(\"LOAD_IND_U64\", Arguments.TwoRegOneImm, 1),\n /* 131 */ instruction(\"ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 132 */ instruction(\"AND_IMM\", Arguments.TwoRegOneImm, 1),\n /* 133 */ instruction(\"XOR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 134 */ instruction(\"OR_IMM\", Arguments.TwoRegOneImm, 1),\n /* 135 */ instruction(\"MUL_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 136 */ instruction(\"SET_LT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 137 */ instruction(\"SET_LT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 138 */ instruction(\"SHLO_L_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 139 */ instruction(\"SHLO_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n\n /* 140 */ instruction(\"SHAR_R_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 141 */ instruction(\"NEG_ADD_IMM_32\", Arguments.TwoRegOneImm, 1),\n /* 142 */ instruction(\"SET_GT_U_IMM\", Arguments.TwoRegOneImm, 1),\n /* 143 */ instruction(\"SET_GT_S_IMM\", Arguments.TwoRegOneImm, 1),\n /* 144 */ instruction(\"SHLO_L_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 145 */ instruction(\"SHLO_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 146 */ instruction(\"SHAR_R_IMM_ALT_32\", Arguments.TwoRegOneImm, 1),\n /* 147 */ instruction(\"CMOV_IZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 148 */ instruction(\"CMOV_NZ_IMM\", Arguments.TwoRegOneImm, 1),\n /* 149 */ instruction(\"ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n\n /* 150 */ instruction(\"MUL_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 151 */ instruction(\"SHLO_L_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 152 */ instruction(\"SHLO_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 153 */ instruction(\"SHAR_R_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 154 */ instruction(\"NEG_ADD_IMM_64\", Arguments.TwoRegOneImm, 1),\n /* 155 */ instruction(\"SHLO_L_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 156 */ instruction(\"SHLO_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 157 */ instruction(\"SHAR_R_IMM_ALT_64\", Arguments.TwoRegOneImm, 1),\n /* 158 */ instruction(\"ROT_R_64_IMM\", Arguments.TwoRegOneImm, 1),\n /* 159 */ instruction(\"ROT_R_64_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n\n /* 160 */ instruction(\"ROT_R_32_IMM\", Arguments.TwoRegOneImm, 1),\n /* 161 */ instruction(\"ROT_R_32_IMM_ALT\", Arguments.TwoRegOneImm, 1),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 170 */ instruction(\"BRANCH_EQ\", Arguments.TwoRegOneOff, 1, true),\n /* 171 */ instruction(\"BRANCH_NE\", Arguments.TwoRegOneOff, 1, true),\n /* 172 */ instruction(\"BRANCH_LT_U\", Arguments.TwoRegOneOff, 1, true),\n /* 173 */ instruction(\"BRANCH_LT_S\", Arguments.TwoRegOneOff, 1, true),\n /* 174 */ instruction(\"BRANCH_GE_U\", Arguments.TwoRegOneOff, 1, true),\n /* 175 */ instruction(\"BRANCH_GE_S\", Arguments.TwoRegOneOff, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 180 */ instruction(\"LOAD_IMM_JUMP_IND\", Arguments.TwoRegTwoImm, 1, true),\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n MISSING_INSTRUCTION,\n\n /* 190 */ instruction(\"ADD_32\", Arguments.ThreeReg, 1),\n /* 191 */ instruction(\"SUB_32\", Arguments.ThreeReg, 1),\n /* 192 */ instruction(\"MUL_32\", Arguments.ThreeReg, 1),\n /* 193 */ instruction(\"DIV_U_32\", Arguments.ThreeReg, 1),\n /* 194 */ instruction(\"DIV_S_32\", Arguments.ThreeReg, 1),\n /* 195 */ instruction(\"REM_U_32\", Arguments.ThreeReg, 1),\n /* 196 */ instruction(\"REM_S_32\", Arguments.ThreeReg, 1),\n /* 197 */ instruction(\"SHLO_L_32\", Arguments.ThreeReg, 1),\n /* 198 */ instruction(\"SHLO_R_32\", Arguments.ThreeReg, 1),\n /* 199 */ instruction(\"SHAR_R_32\", Arguments.ThreeReg, 1),\n\n /* 200 */ instruction(\"ADD_64\", Arguments.ThreeReg, 1),\n /* 201 */ instruction(\"SUB_64\", Arguments.ThreeReg, 1),\n /* 202 */ instruction(\"MUL_64\", Arguments.ThreeReg, 1),\n /* 203 */ instruction(\"DIV_U_64\", Arguments.ThreeReg, 1),\n /* 204 */ instruction(\"DIV_S_64\", Arguments.ThreeReg, 1),\n /* 205 */ instruction(\"REM_U_64\", Arguments.ThreeReg, 1),\n /* 206 */ instruction(\"REM_S_64\", Arguments.ThreeReg, 1),\n /* 207 */ instruction(\"SHLO_L_64\", Arguments.ThreeReg, 1),\n /* 208 */ instruction(\"SHLO_R_64\", Arguments.ThreeReg, 1),\n /* 209 */ instruction(\"SHAR_R_64\", Arguments.ThreeReg, 1),\n\n /* 210 */ instruction(\"AND\", Arguments.ThreeReg, 1),\n /* 211 */ instruction(\"XOR\", Arguments.ThreeReg, 1),\n /* 212 */ instruction(\"OR\", Arguments.ThreeReg, 1),\n /* 213 */ instruction(\"MUL_UPPER_S_S\", Arguments.ThreeReg, 1),\n /* 214 */ instruction(\"MUL_UPPER_U_U\", Arguments.ThreeReg, 1),\n /* 215 */ instruction(\"MUL_UPPER_S_U\", Arguments.ThreeReg, 1),\n /* 216 */ instruction(\"SET_LT_U\", Arguments.ThreeReg, 1),\n /* 217 */ instruction(\"SET_LT_S\", Arguments.ThreeReg, 1),\n /* 218 */ instruction(\"CMOV_IZ\", Arguments.ThreeReg, 1),\n /* 219 */ instruction(\"CMOV_NZ\", Arguments.ThreeReg, 1),\n\n /* 220 */ instruction(\"ROT_L_64\", Arguments.ThreeReg, 1),\n /* 221 */ instruction(\"ROT_L_32\", Arguments.ThreeReg, 1),\n /* 222 */ instruction(\"ROT_R_64\", Arguments.ThreeReg, 1),\n /* 223 */ instruction(\"ROT_R_32\", Arguments.ThreeReg, 1),\n /* 224 */ instruction(\"AND_INV\", Arguments.ThreeReg, 1),\n /* 225 */ instruction(\"OR_INV\", Arguments.ThreeReg, 1),\n /* 226 */ instruction(\"XNOR\", Arguments.ThreeReg, 1),\n /* 227 */ instruction(\"MAX\", Arguments.ThreeReg, 1),\n /* 228 */ instruction(\"MAX_U\", Arguments.ThreeReg, 1),\n /* 229 */ instruction(\"MIN\", Arguments.ThreeReg, 1),\n\n /* 230 */ instruction(\"MIN_U\", Arguments.ThreeReg, 1),\n];\n","import { Args, Arguments, DECODERS, REQUIRED_BYTES } from \"./arguments\";\nimport { Decoder } from \"./codec\";\nimport { INSTRUCTIONS, MISSING_INSTRUCTION } from \"./instructions\";\nimport { reg, u32SignExtend } from \"./instructions/utils\";\nimport { Registers } from \"./registers\";\n\nexport type ProgramCounter = u32;\n\nconst MAX_SKIP: u32 = 24;\n\nexport class CodeAndMetadata {\n constructor(\n readonly code: Uint8Array,\n readonly metadata: Uint8Array,\n ) {}\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/109a01109a01?v=0.6.5 */\nexport function extractCodeAndMetadata(data: Uint8Array): CodeAndMetadata {\n const decoder = new Decoder(data);\n const metadataLength = decoder.varU32();\n const metadata = decoder.bytes(metadataLength);\n const code = decoder.remainingBytes();\n return new CodeAndMetadata(code, metadata);\n}\n\n/** Convert `u8` to `Uint8Array` */\nexport function liftBytes(data: u8[]): Uint8Array {\n const p = new Uint8Array(data.length);\n p.set(data, 0);\n return p;\n}\n\n/** Convert `Uint8Array` to `u8` */\nexport function lowerBytes(data: Uint8Array): u8[] {\n const r = new Array(data.length);\n for (let i = 0; i < data.length; i++) {\n r[i] = data[i];\n }\n return r;\n}\n\n/** https://graypaper.fluffylabs.dev/#/cc517d7/234f01234f01?v=0.6.5 */\nexport function deblob(program: Uint8Array): Program {\n const decoder = new Decoder(program);\n\n // number of items in the jump table\n const jumpTableLength = decoder.varU32();\n\n // how many bytes are used to encode a single item of the jump table\n const jumpTableItemLength = decoder.u8();\n // the length of the code (in bytes).\n const codeLength = decoder.varU32();\n\n const jumpTableLengthInBytes = jumpTableLength * jumpTableItemLength;\n const rawJumpTable = decoder.bytes(jumpTableLengthInBytes);\n\n const rawCode = decoder.bytes(codeLength);\n const rawMask = decoder.bytes((codeLength + 7) / 8);\n\n const mask = new Mask(rawMask, codeLength);\n const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);\n const basicBlocks = new BasicBlocks(rawCode, mask);\n\n return new Program(rawCode, mask, jumpTable, basicBlocks);\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/236e01236e01?v=0.6.5\n */\nexport class Mask {\n /**\n * NOTE: might be longer than code (bit-alignment).\n * In this array we keep `skip(n) + 1` from the Gray Paper\n * for non-instruction bytes.\n * In case the in-code mask says there is an instruction at that location\n * we store `0` here.\n */\n readonly bytesToSkip: StaticArray;\n\n constructor(packedMask: Uint8Array, codeLength: i32) {\n this.bytesToSkip = new StaticArray(codeLength);\n let lastInstructionOffset: u32 = 0;\n for (let i: i32 = packedMask.length - 1; i >= 0; i -= 1) {\n let bits = packedMask[i];\n const index = i * 8;\n for (let b = 7; b >= 0; b--) {\n const isSet = bits & 0b1000_0000;\n bits = bits << 1;\n if (index + b < codeLength) {\n lastInstructionOffset = isSet ? 0 : lastInstructionOffset + 1;\n this.bytesToSkip[index + b] = lastInstructionOffset < MAX_SKIP + 1 ? lastInstructionOffset : MAX_SKIP + 1;\n }\n }\n }\n }\n\n isInstruction(index: ProgramCounter): boolean {\n if (index >= this.bytesToSkip.length) {\n return false;\n }\n\n return this.bytesToSkip[u32(index)] === 0;\n }\n\n /**\n * Given we are at instruction `i`, how many bytes should be skipped to\n * reach the next instruction (i.e. `skip(i) + 1` from the GP).\n *\n * NOTE: we don't guarantee that `isInstruction()` will return true\n * for the new program counter, since `skip` function is bounded by\n * an upper limit of `24` bytes.\n */\n skipBytesToNextInstruction(i: u32): u32 {\n if (i + 1 < this.bytesToSkip.length) {\n return this.bytesToSkip[i + 1];\n }\n\n return 0;\n }\n\n toString(): string {\n let v = \"Mask[\";\n for (let i = 0; i < this.bytesToSkip.length; i += 1) {\n v += `${this.bytesToSkip[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport enum BasicBlock {\n NONE = 0,\n START = 2,\n END = 4,\n}\n\n/**\n * https://graypaper.fluffylabs.dev/#/cc517d7/23fe0123fe01?v=0.6.5\n */\nexport class BasicBlocks {\n readonly isStartOrEnd: StaticArray;\n\n constructor(code: Uint8Array, mask: Mask) {\n const len = code.length;\n const isStartOrEnd = new StaticArray(len);\n if (len > 0) {\n isStartOrEnd[0] = BasicBlock.START;\n }\n for (let n: i32 = 0; n < len; n += 1) {\n // we only track end-blocks for instructions.\n const isInstructionInMask = mask.isInstruction(n);\n if (!isInstructionInMask) {\n continue;\n }\n\n const skipArgs = mask.skipBytesToNextInstruction(n);\n const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];\n const isTerminating = iData.isTerminating;\n\n if (isTerminating) {\n // skip is always 0?\n const newBlockStart = n + 1 + skipArgs;\n // mark the beginning of the next block\n if (newBlockStart < len) {\n isStartOrEnd[newBlockStart] = BasicBlock.START;\n }\n // and mark current instruction as terminating\n isStartOrEnd[n] |= BasicBlock.END;\n }\n }\n this.isStartOrEnd = isStartOrEnd;\n }\n\n isStart(newPc: u32): boolean {\n if (newPc < this.isStartOrEnd.length) {\n return (this.isStartOrEnd[newPc] & BasicBlock.START) > 0;\n }\n return false;\n }\n\n toString(): string {\n let v = \"BasicBlocks[\";\n for (let i = 0; i < this.isStartOrEnd.length; i += 1) {\n let t = \"\";\n const isStart = (this.isStartOrEnd[i] & BasicBlock.START) > 0;\n t += isStart ? \"start\" : \"\";\n const isEnd = (this.isStartOrEnd[i] & BasicBlock.END) > 0;\n t += isEnd ? \"end\" : \"\";\n if (t.length > 0) {\n v += `${i} -> ${t}, `;\n }\n }\n return `${v}]`;\n }\n}\n\nexport class JumpTable {\n readonly jumps: StaticArray;\n\n constructor(itemBytes: u8, data: Uint8Array) {\n const jumps = new StaticArray(itemBytes > 0 ? data.length / itemBytes : 0);\n\n for (let i = 0; i < data.length; i += itemBytes) {\n let num: u64 = 0;\n for (let j: i32 = itemBytes - 1; j >= 0; j--) {\n let nextNum: u64 = num << 8;\n let isOverflow = nextNum < num;\n nextNum = nextNum + u64(data[i + j]);\n isOverflow = isOverflow || nextNum < num;\n // handle overflow\n num = isOverflow ? u64.MAX_VALUE : nextNum;\n }\n jumps[i / itemBytes] = num;\n }\n\n this.jumps = jumps;\n }\n\n toString(): string {\n let v = \"JumpTable[\";\n for (let i = 0; i < this.jumps.length; i += 1) {\n v += `${i} -> ${this.jumps[i]}, `;\n }\n return `${v}]`;\n }\n}\n\nexport class Program {\n constructor(\n public readonly code: Uint8Array,\n public readonly mask: Mask,\n public readonly jumpTable: JumpTable,\n public readonly basicBlocks: BasicBlocks,\n ) {}\n\n toString(): string {\n return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;\n }\n}\n\nexport function decodeArguments(kind: Arguments, data: Uint8Array, lim: u32): Args {\n if (data.length < REQUIRED_BYTES[kind]) {\n // in case we have less data than needed we extend the data with zeros.\n const extended = new Uint8Array(REQUIRED_BYTES[kind]);\n for (let i = 0; i < data.length; i++) {\n extended[i] = data[i];\n }\n return DECODERS[kind](extended, lim);\n }\n return DECODERS[kind](data, lim);\n}\n\nclass ResolvedArguments {\n a: i64 = 0;\n b: i64 = 0;\n c: i64 = 0;\n d: i64 = 0;\n decoded: Args = new Args();\n}\n\nexport function resolveArguments(\n kind: Arguments,\n data: Uint8Array,\n lim: u32,\n registers: Registers,\n): ResolvedArguments | null {\n const args = decodeArguments(kind, data, lim);\n if (args === null) {\n return null;\n }\n\n const resolved = new ResolvedArguments();\n resolved.decoded = args;\n\n switch (kind) {\n case Arguments.Zero:\n return resolved;\n case Arguments.OneImm:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.TwoImm:\n resolved.a = u32SignExtend(args.a);\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneOff:\n resolved.a = u32SignExtend(args.a);\n return resolved;\n case Arguments.OneRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n return resolved;\n case Arguments.OneRegOneExtImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = (u64(args.a) << 32) + u64(args.b);\n return resolved;\n case Arguments.OneRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.OneRegOneImmOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = u32SignExtend(args.b);\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n return resolved;\n case Arguments.TwoRegOneImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegOneOff:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n return resolved;\n case Arguments.TwoRegTwoImm:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = u32SignExtend(args.c);\n resolved.d = u32SignExtend(args.d);\n return resolved;\n case Arguments.ThreeReg:\n resolved.a = registers[reg(args.a)];\n resolved.b = registers[reg(args.b)];\n resolved.c = registers[reg(args.c)];\n return resolved;\n default:\n throw new Error(`Unhandled arguments kind: ${kind}`);\n }\n}\n","import { Arguments } from \"./arguments\";\nimport { jump_ind } from \"./instructions/jump\";\nimport { trap } from \"./instructions/misc\";\nimport { InstructionRun } from \"./instructions/outcome\";\nimport { RUN } from \"./instructions-exe\";\nimport { BasicBlocks, deblob, decodeArguments, JumpTable, Mask } from \"./program\";\nimport { Assert, Test, test } from \"./test\";\n\nexport function u8arr(data: number[]): Uint8Array {\n const ret = new Uint8Array(data.length);\n ret.set(data, 0);\n return ret;\n}\n\nexport const TESTS: Test[] = [\n test(\"should parse packed mask correctly\", () => {\n const mask = new Mask(u8arr([0b0001_0000, 0b1000_0000, 0b1111_1000]), 21);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [4, 3, 2, 1, 0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 3, 2, 1, 0, 0],\n );\n\n assert.isEqual(mask.isInstruction(0), false);\n assert.isEqual(mask.isInstruction(4), true);\n\n assert.isEqual(mask.skipBytesToNextInstruction(20), 0);\n assert.isEqual(mask.skipBytesToNextInstruction(22), 0);\n return assert;\n }),\n\n test(\"should not allow skipping more than 24 bytes\", () => {\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n\n const assert = new Assert();\n assert.isArrayEqual(\n mask.bytesToSkip.slice(),\n [\n 0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2,\n 1, 0,\n ],\n );\n return assert;\n }),\n\n test(\"should decode arguments correctly\", () => {\n const data = u8arr([0xff, 0xff, 0xff, 0xff]);\n const args = decodeArguments(Arguments.OneImm, data, 4);\n\n const assert = new Assert();\n assert.isEqual(args.a, -1, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should decode positive bounded by skip\", () => {\n const data = u8arr([0x05, 0x05]);\n const args = decodeArguments(Arguments.OneImm, data, 1);\n\n const assert = new Assert();\n assert.isEqual(args.a, 5, \"a\");\n assert.isEqual(args.b, 0, \"b\");\n assert.isEqual(args.c, 0, \"c\");\n assert.isEqual(args.d, 0, \"d\");\n return assert;\n }),\n\n test(\"should deblob program\", () => {\n const raw = u8arr([\n 0, 0, 33, 51, 8, 1, 51, 9, 1, 40, 3, 0, 149, 119, 255, 81, 7, 12, 100, 138, 200, 152, 8, 100, 169, 40, 243, 100,\n 135, 51, 8, 51, 9, 1, 50, 0, 73, 147, 82, 213, 0,\n ]);\n const program = deblob(raw);\n const assert = new Assert();\n assert.isEqual(\n program.mask.toString(),\n \"Mask[0, 2, 1, 0, 2, 1, 0, 1, 0, 0, 2, 1, 0, 2, 1, 0, 1, 0, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, ]\",\n );\n assert.isEqual(program.jumpTable.toString(), \"JumpTable[]\");\n assert.isEqual(\n program.basicBlocks.toString(),\n \"BasicBlocks[0 -> start, 6 -> end, 8 -> startend, 9 -> start, 12 -> end, 15 -> start, 22 -> end, 24 -> start, 30 -> end, 31 -> startend, ]\",\n );\n return assert;\n }),\n\n test(\"should construct basic blocks correctly based on skip\", () => {\n const code = u8arr([\n opcode(trap),\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n opcode(jump_ind),\n ]);\n const mask = new Mask(u8arr([0b0000_0001, 0b0000_0000, 0b0000_0000, 0b1000_0000]), 32);\n const basicBlocks = new BasicBlocks(code, mask);\n const assert = new Assert();\n assert.isEqual(\n mask.toString(),\n \"Mask[0, 25, 25, 25, 25, 25, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, ]\",\n );\n assert.isEqual(basicBlocks.toString(), \"BasicBlocks[0 -> startend, 26 -> start, 31 -> end, ]\");\n return assert;\n }),\n test(\"should parse jump table with large numbers\", () => {\n const jumpTable = new JumpTable(\n 10,\n u8arr([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 2, 2, 2, 0]),\n );\n const assert = new Assert();\n assert.isEqual(\n jumpTable.toString(),\n \"JumpTable[0 -> 18446744073709551615, 1 -> 18446744073709551615, 2 -> 18446744073709551615, ]\",\n );\n return assert;\n }),\n];\n\nfunction opcode(search: InstructionRun): number {\n const idx = RUN.indexOf(search);\n if (idx < 0) {\n throw new Error(\"Opcode not found in RUN table for instruction\");\n }\n return idx;\n}\n","import { Decoder } from \"./codec\";\nimport { Memory, MemoryBuilder } from \"./memory\";\nimport { Access, PAGE_SIZE, PAGE_SIZE_SHIFT, SEGMENT_SIZE, SEGMENT_SIZE_SHIFT } from \"./memory-page\";\nimport { deblob, Program } from \"./program\";\nimport { NO_OF_REGISTERS, Registers } from \"./registers\";\n\n/** `Z_I`: https://graypaper.fluffylabs.dev/#/ab2cdbd/2daf002daf00?v=0.7.2 */\nexport const MAX_ARGS_LEN: u32 = 2 ** 24;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d47022d4702?v=0.7.2 */\nexport const ARGS_SEGMENT_START: u32 = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2d33022d3502?v=0.7.2 */\nexport const STACK_SEGMENT_END: u32 = ARGS_SEGMENT_START - SEGMENT_SIZE;\n\n/** https://graypaper.fluffylabs.dev/#/ab2cdbd/2da3002da300?v=0.7.2 */\nexport function decodeSpi(data: Uint8Array, args: Uint8Array): StandardProgram {\n const argsLength = args.length;\n if (argsLength > MAX_ARGS_LEN) {\n throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);\n }\n\n const decoder = new Decoder(data);\n\n const roLength = decoder.u24();\n const rwLength = decoder.u24();\n const heapPages = decoder.u16();\n const stackSize = decoder.u24();\n\n const roMem = decoder.bytes(roLength);\n const rwMem = decoder.bytes(rwLength);\n\n const codeLength = decoder.u32();\n const code = decoder.bytes(codeLength);\n decoder.finish();\n\n const program = deblob(code);\n\n // building memory\n const builder = new MemoryBuilder();\n\n const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);\n const heapZerosStart = heapStart + alignToPageSize(rwLength);\n const heapZerosLength = heapPages * PAGE_SIZE;\n const heapZerosEnd = heapZerosStart + heapZerosLength;\n\n const stackLength = alignToPageSize(stackSize);\n // stackLength is bounded to `2**24`, so there is no risk of underflow here.\n const stackStart = STACK_SEGMENT_END - stackLength;\n\n // readable memory\n if (roLength > 0) {\n builder.setData(Access.Read, SEGMENT_SIZE, roMem);\n }\n if (argsLength > 0) {\n builder.setData(Access.Read, ARGS_SEGMENT_START, args);\n }\n\n // writable memory\n if (rwLength > 0) {\n builder.setData(Access.Write, heapStart, rwMem);\n }\n if (heapZerosLength > 0) {\n builder.setEmpty(Access.Write, heapZerosStart, heapZerosLength);\n }\n if (stackLength > 0) {\n builder.setEmpty(Access.Write, stackStart, stackLength);\n }\n\n const memory = builder.build(heapZerosEnd);\n\n // build registers\n const registers: Registers = new StaticArray(NO_OF_REGISTERS);\n registers[0] = 0xffff_0000;\n registers[1] = STACK_SEGMENT_END;\n registers[7] = ARGS_SEGMENT_START;\n registers[8] = argsLength;\n\n return new StandardProgram(program, memory, registers);\n}\n\nfunction alignToPageSize(size: u32): u32 {\n return ((size + PAGE_SIZE - 1) >> PAGE_SIZE_SHIFT) << PAGE_SIZE_SHIFT;\n}\n\nfunction alignToSegmentSize(size: u32): u32 {\n return ((size + SEGMENT_SIZE - 1) >> SEGMENT_SIZE_SHIFT) << SEGMENT_SIZE_SHIFT;\n}\n\n/**\n * SPI Program with memory and registers.\n *\n * https://graypaper.fluffylabs.dev/#/ab2cdbd/2d13002d1400?v=0.7.2\n */\nexport class StandardProgram {\n metadata: Uint8Array = new Uint8Array(0);\n pc: u32 = 0;\n gas: i64 = 0;\n\n constructor(\n public readonly program: Program,\n public readonly memory: Memory,\n public readonly registers: Registers,\n ) {}\n\n toString(): string {\n return `StandardProgram { program: ${this.program}, memory_pages: ${this.memory.pages.size}, registers: ${this.registers} }`;\n }\n}\n","import { liftBytes } from \"./program\";\nimport { decodeSpi } from \"./spi\";\nimport { Assert, Test, test } from \"./test\";\n\nexport const TESTS: Test[] = [\n test(\"should decode standard program\", () => {\n const PROGRAM = liftBytes([\n 0x04, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0xab, 0xcd, 0xef, 0x01, 0x12, 0x34, 0x07, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x03, 0xc8, 0x87, 0x09, 0x01,\n ]);\n const ARGS = liftBytes([0x12, 0x34, 0x56]);\n\n const spi = decodeSpi(PROGRAM, ARGS);\n\n const assert = new Assert();\n assert.isEqual(\n spi.toString(),\n \"StandardProgram { program: Program { code: 200,135,9, mask: Mask[0, 2, 1, ], jumpTable: JumpTable[], basicBlocks: BasicBlocks[0 -> start, ] }, memory_pages: 7, registers: 4294901760,4278059008,0,0,0,0,0,4278124544,3,0,0,0,0 }\",\n );\n return assert;\n }),\n];\n","import * as bit from \"./instructions/bit.test\";\nimport * as branch from \"./instructions/branch.test\";\nimport * as logic from \"./instructions/logic.test\";\nimport * as math from \"./instructions/math.test\";\nimport * as rot from \"./instructions/rot.test\";\nimport * as memory from \"./memory.test\";\nimport * as program from \"./program.test\";\nimport * as spi from \"./spi.test\";\nimport { Assert, Test } from \"./test\";\n\nexport function runAllTests(): void {\n let a: u64 = 0;\n\n a += run(bit.TESTS, \"bit.ts\");\n a += run(branch.TESTS, \"branch.ts\");\n a += run(logic.TESTS, \"logic.ts\");\n a += run(math.TESTS, \"math.ts\");\n a += run(memory.TESTS, \"memory.ts\");\n a += run(program.TESTS, \"program.ts\");\n a += run(rot.TESTS, \"rot.ts\");\n a += run(spi.TESTS, \"spi.ts\");\n\n const okay = u32(a >> 32);\n const total = u32(a);\n\n printSummary(\"\\n\\nTotal\", okay, total);\n if (okay !== total) {\n throw new Error(\"Some tests failed.\");\n }\n}\n\nfunction run(tests: Test[], file: string): u64 {\n let ok = 0;\n console.log(`> ${file}`);\n for (let i = 0; i < tests.length; i++) {\n console.log(` >>> ${tests[i].name}`);\n const res = tests[i].ptr(new Assert());\n if (res.isOkay) {\n console.log(` <<< ${tests[i].name} ✅`);\n ok += 1;\n } else {\n for (let j = 0; j < res.errors.length; j++) {\n console.log(` ${res.errors[j]}`);\n }\n console.log(` <<< ${tests[i].name} 🔴`);\n }\n }\n\n printSummary(`< ${file}`, ok, tests.length);\n\n return (u64(ok) << 32) + tests.length;\n}\n\nfunction printSummary(msg: string, okay: u32, total: u32): void {\n const ico = okay === total ? \"✅\" : \"🔴\";\n console.log(`${msg} ${okay} / ${total} ${ico}`);\n}\n","type auto = i32;\n\n@final export abstract class Function {\n private _index: u32;\n private _env: usize;\n\n // @ts-ignore: this on getter\n get index(this: T): u32 {\n return load(changetype(this), offsetof>(\"_index\"));\n }\n\n // @ts-ignore: this on getter\n get name(this: T): string {\n return \"\";\n }\n\n // @ts-ignore: this on getter\n get length(this: T): i32 {\n // @ts-ignore: T is function\n return lengthof();\n }\n\n // @ts-ignore: T is function\n @builtin call(thisArg: thisof | null, ...args: auto[]): returnof {\n return unreachable();\n }\n\n toString(this: T): string {\n return \"function() { [native code] }\";\n }\n\n // RT integration\n\n @unsafe private __visit(cookie: u32): void {\n // Env is either `null` (nop) or compiler-generated\n __visit(this._env, cookie);\n }\n}\n"]} \ No newline at end of file diff --git a/build/test.wat b/build/test.wat deleted file mode 100644 index 313c8de..0000000 --- a/build/test.wat +++ /dev/null @@ -1,45430 +0,0 @@ -(module - (type $0 (func (param i32) (result i32))) - (type $1 (func (param i32 i32 i32) (result i32))) - (type $2 (func (param i32 i32))) - (type $3 (func (param i32 i32) (result i32))) - (type $4 (func)) - (type $5 (func (param i32 i32 i32))) - (type $6 (func (param i32 i32 i32 i32) (result i32))) - (type $7 (func (param i32))) - (type $8 (func (param i32 i32 i32 i32))) - (type $9 (func (param i64 i64) (result i64))) - (type $10 (func (param i64 i32) (result i32))) - (type $11 (func (result i32))) - (type $12 (func (param i32) (result i64))) - (type $13 (func (param i32 i64))) - (type $14 (func (param i32 i32 i64) (result i32))) - (type $15 (func (param i64) (result i32))) - (type $16 (func (param i32 i32 i64))) - (type $17 (func (param i32 i64 i32))) - (type $18 (func (param i32 i32 i32 i32 i32) (result i32))) - (type $19 (func (param i32 i32) (result i64))) - (type $20 (func (param i32 i64 i64 i32))) - (type $21 (func (param i64) (result i64))) - (type $22 (func (param i32 i64 i32 i32))) - (type $23 (func (param i32 i32 i32 i32 i32))) - (type $24 (func (param i32 i32 i64 i32) (result i32))) - (type $25 (func (param i32 i64) (result i32))) - (type $26 (func (param i32) (result f64))) - (type $27 (func (param i32 i32 f64))) - (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32))) - (import "env" "console.log" (func $~lib/bindings/dom/console.log (param i32))) - (global $assembly/arguments/Arguments.Zero i32 (i32.const 0)) - (global $assembly/arguments/Arguments.OneImm i32 (i32.const 1)) - (global $assembly/arguments/Arguments.TwoImm i32 (i32.const 2)) - (global $assembly/arguments/Arguments.OneOff i32 (i32.const 3)) - (global $assembly/arguments/Arguments.OneRegOneImm i32 (i32.const 4)) - (global $assembly/arguments/Arguments.OneRegOneExtImm i32 (i32.const 5)) - (global $assembly/arguments/Arguments.OneRegTwoImm i32 (i32.const 6)) - (global $assembly/arguments/Arguments.OneRegOneImmOneOff i32 (i32.const 7)) - (global $assembly/arguments/Arguments.TwoReg i32 (i32.const 8)) - (global $assembly/arguments/Arguments.TwoRegOneImm i32 (i32.const 9)) - (global $assembly/arguments/Arguments.TwoRegOneOff i32 (i32.const 10)) - (global $assembly/arguments/Arguments.TwoRegTwoImm i32 (i32.const 11)) - (global $assembly/arguments/Arguments.ThreeReg i32 (i32.const 12)) - (global $assembly/arguments/RELEVANT_ARGS i32 (i32.const 112)) - (global $assembly/arguments/REQUIRED_BYTES i32 (i32.const 240)) - (global $~lib/rt/itcms/total (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/threshold (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/state (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/visitCount (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/pinSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/iter (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/toSpace (mut i32) (i32.const 0)) - (global $~lib/rt/itcms/white (mut i32) (i32.const 0)) - (global $~lib/shared/runtime/Runtime.Stub i32 (i32.const 0)) - (global $~lib/shared/runtime/Runtime.Minimal i32 (i32.const 1)) - (global $~lib/shared/runtime/Runtime.Incremental i32 (i32.const 2)) - (global $~lib/rt/itcms/fromSpace (mut i32) (i32.const 0)) - (global $~lib/rt/tlsf/ROOT (mut i32) (i32.const 0)) - (global $~lib/native/ASC_LOW_MEMORY_LIMIT i32 (i32.const 0)) - (global $~lib/builtins/i32.MAX_VALUE i32 (i32.const 2147483647)) - (global $~argumentsLength (mut i32) (i32.const 0)) - (global $assembly/arguments/DECODERS i32 (i32.const 1248)) - (global $assembly/registers/NO_OF_REGISTERS i32 (i32.const 13)) - (global $assembly/registers/REG_SIZE_BYTES i32 (i32.const 8)) - (global $~lib/native/ASC_SHRINK_LEVEL i32 (i32.const 0)) - (global $assembly/memory-page/PAGE_SIZE (mut i32) (i32.const 0)) - (global $assembly/memory-page/PAGE_SIZE_SHIFT i32 (i32.const 12)) - (global $assembly/memory-page/SEGMENT_SIZE (mut i32) (i32.const 0)) - (global $assembly/memory-page/SEGMENT_SIZE_SHIFT i32 (i32.const 16)) - (global $assembly/memory-page/RESERVED_MEMORY (mut i32) (i32.const 0)) - (global $assembly/memory-page/RESERVED_PAGES (mut i32) (i32.const 0)) - (global $assembly/memory-page/ALLOCATE_EAGERLY (mut i32) (i32.const 0)) - (global $assembly/memory-page/Access.None i32 (i32.const 0)) - (global $assembly/memory-page/Access.Read i32 (i32.const 1)) - (global $assembly/memory-page/Access.Write i32 (i32.const 2)) - (global $assembly/memory/NO_PAGE_FAULT (mut i32) (i32.const 0)) - (global $assembly/memory/MEMORY_SIZE i64 (i64.const 4294967296)) - (global $~lib/native/ASC_RUNTIME i32 (i32.const 2)) - (global $assembly/memory/EMPTY_UINT8ARRAY (mut i32) (i32.const 0)) - (global $assembly/memory/EMPTY_PAGE (mut i32) (i32.const 0)) - (global $assembly/instructions/outcome/Result.PANIC i32 (i32.const 0)) - (global $assembly/instructions/outcome/Result.FAULT i32 (i32.const 1)) - (global $assembly/instructions/outcome/Result.FAULT_ACCESS i32 (i32.const 2)) - (global $assembly/instructions/outcome/Result.HOST i32 (i32.const 3)) - (global $assembly/instructions/outcome/Outcome.Ok i32 (i32.const 0)) - (global $assembly/instructions/outcome/Outcome.StaticJump i32 (i32.const 1)) - (global $assembly/instructions/outcome/Outcome.DynamicJump i32 (i32.const 2)) - (global $assembly/instructions/outcome/Outcome.Result i32 (i32.const 3)) - (global $assembly/instructions/bit/count_set_bits_64 i32 (i32.const 1472)) - (global $assembly/instructions/bit/count_set_bits_32 i32 (i32.const 1504)) - (global $assembly/instructions/bit/leading_zero_bits_64 i32 (i32.const 1536)) - (global $assembly/instructions/bit/leading_zero_bits_32 i32 (i32.const 1568)) - (global $assembly/instructions/bit/trailing_zero_bits_64 i32 (i32.const 1600)) - (global $assembly/instructions/bit/trailing_zero_bits_32 i32 (i32.const 1632)) - (global $assembly/instructions/bit/sign_extend_8 i32 (i32.const 1664)) - (global $assembly/instructions/bit/sign_extend_16 i32 (i32.const 1696)) - (global $assembly/instructions/bit/zero_extend_16 i32 (i32.const 1728)) - (global $assembly/instructions/bit/reverse_bytes i32 (i32.const 1760)) - (global $~lib/builtins/u32.MAX_VALUE i32 (i32.const -1)) - (global $assembly/instructions/bit.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/instructions/branch/branch_eq_imm i32 (i32.const 5440)) - (global $assembly/instructions/branch/branch_ne_imm i32 (i32.const 5472)) - (global $assembly/instructions/branch/branch_lt_u_imm i32 (i32.const 5504)) - (global $assembly/instructions/branch/branch_le_u_imm i32 (i32.const 5536)) - (global $assembly/instructions/branch/branch_ge_u_imm i32 (i32.const 5568)) - (global $assembly/instructions/branch/branch_gt_u_imm i32 (i32.const 5600)) - (global $assembly/instructions/branch/branch_lt_s_imm i32 (i32.const 5632)) - (global $assembly/instructions/branch/branch_le_s_imm i32 (i32.const 5664)) - (global $assembly/instructions/branch/branch_ge_s_imm i32 (i32.const 5696)) - (global $assembly/instructions/branch/branch_gt_s_imm i32 (i32.const 5728)) - (global $assembly/instructions/branch/branch_eq i32 (i32.const 5760)) - (global $assembly/instructions/branch/branch_ne i32 (i32.const 5792)) - (global $assembly/instructions/branch/branch_lt_u i32 (i32.const 5824)) - (global $assembly/instructions/branch/branch_lt_s i32 (i32.const 5856)) - (global $assembly/instructions/branch/branch_ge_u i32 (i32.const 5888)) - (global $assembly/instructions/branch/branch_ge_s i32 (i32.const 5920)) - (global $assembly/instructions/branch.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/instructions/logic/and_imm i32 (i32.const 6224)) - (global $assembly/instructions/logic/xor_imm i32 (i32.const 6256)) - (global $assembly/instructions/logic/or_imm i32 (i32.const 6288)) - (global $assembly/instructions/logic/and i32 (i32.const 6320)) - (global $assembly/instructions/logic/xor i32 (i32.const 6352)) - (global $assembly/instructions/logic/or i32 (i32.const 6384)) - (global $assembly/instructions/logic/and_inv i32 (i32.const 6416)) - (global $assembly/instructions/logic/or_inv i32 (i32.const 6448)) - (global $assembly/instructions/logic/xnor i32 (i32.const 6480)) - (global $assembly/instructions/logic.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/instructions/math/add_imm_32 i32 (i32.const 6720)) - (global $assembly/instructions/math/mul_imm_32 i32 (i32.const 6752)) - (global $assembly/instructions/math/neg_add_imm_32 i32 (i32.const 6784)) - (global $assembly/instructions/math/add_imm i32 (i32.const 6816)) - (global $assembly/instructions/math/mul_imm i32 (i32.const 6848)) - (global $assembly/instructions/math/neg_add_imm i32 (i32.const 6880)) - (global $assembly/instructions/math/add_32 i32 (i32.const 6912)) - (global $assembly/instructions/math/sub_32 i32 (i32.const 6944)) - (global $assembly/instructions/math/mul_32 i32 (i32.const 6976)) - (global $~lib/builtins/u64.MAX_VALUE i64 (i64.const -1)) - (global $assembly/instructions/math/div_u_32 i32 (i32.const 7008)) - (global $~lib/builtins/i32.MIN_VALUE i32 (i32.const -2147483648)) - (global $assembly/instructions/math/div_s_32 i32 (i32.const 7040)) - (global $assembly/instructions/math/rem_u_32 i32 (i32.const 7072)) - (global $assembly/instructions/math/rem_s_32 i32 (i32.const 7104)) - (global $assembly/instructions/math/add_64 i32 (i32.const 7136)) - (global $assembly/instructions/math/sub i32 (i32.const 7168)) - (global $assembly/instructions/math/mul i32 (i32.const 7200)) - (global $assembly/instructions/math/div_u i32 (i32.const 7232)) - (global $~lib/builtins/i64.MIN_VALUE i64 (i64.const -9223372036854775808)) - (global $assembly/instructions/math/div_s i32 (i32.const 7264)) - (global $assembly/instructions/math/rem_u i32 (i32.const 7296)) - (global $assembly/instructions/math/rem_s i32 (i32.const 7328)) - (global $assembly/instructions/math/mul_upper_s_s i32 (i32.const 7360)) - (global $assembly/instructions/math/mul_upper_u_u i32 (i32.const 7392)) - (global $assembly/instructions/math/mul_upper_s_u i32 (i32.const 7424)) - (global $assembly/instructions/math/max i32 (i32.const 7456)) - (global $assembly/instructions/math/max_u i32 (i32.const 7488)) - (global $assembly/instructions/math/min i32 (i32.const 7520)) - (global $assembly/instructions/math/min_u i32 (i32.const 7552)) - (global $assembly/instructions/math.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/instructions/rot/rot_r_64_imm i32 (i32.const 7904)) - (global $assembly/instructions/rot/rot_r_64_imm_alt i32 (i32.const 7936)) - (global $assembly/instructions/rot/rot_r_32_imm i32 (i32.const 7968)) - (global $assembly/instructions/rot/rot_r_32_imm_alt i32 (i32.const 8000)) - (global $assembly/instructions/rot/rot_l_64 i32 (i32.const 8032)) - (global $assembly/instructions/rot/rot_l_32 i32 (i32.const 8064)) - (global $assembly/instructions/rot/rot_r_64 i32 (i32.const 8096)) - (global $assembly/instructions/rot/rot_r_32 i32 (i32.const 8128)) - (global $assembly/instructions/rot.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/memory.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/instructions/jump/jump i32 (i32.const 10576)) - (global $assembly/instructions/jump/jump_ind i32 (i32.const 10608)) - (global $assembly/instructions/jump/load_imm_jump i32 (i32.const 10640)) - (global $assembly/instructions/jump/load_imm_jump_ind i32 (i32.const 10672)) - (global $assembly/instructions/misc/INVALID i32 (i32.const 10704)) - (global $assembly/instructions/misc/trap i32 (i32.const 10736)) - (global $assembly/instructions/misc/fallthrough i32 (i32.const 10768)) - (global $assembly/instructions/misc/ecalli i32 (i32.const 10800)) - (global $assembly/instructions/misc/sbrk i32 (i32.const 10832)) - (global $assembly/instructions/load/load_imm_64 i32 (i32.const 10864)) - (global $assembly/instructions/load/load_imm i32 (i32.const 10896)) - (global $assembly/instructions/load/load_u8 i32 (i32.const 10928)) - (global $assembly/instructions/load/load_i8 i32 (i32.const 10960)) - (global $assembly/instructions/load/load_u16 i32 (i32.const 10992)) - (global $assembly/instructions/load/load_i16 i32 (i32.const 11024)) - (global $assembly/instructions/load/load_u32 i32 (i32.const 11056)) - (global $assembly/instructions/load/load_i32 i32 (i32.const 11088)) - (global $assembly/instructions/load/load_u64 i32 (i32.const 11120)) - (global $assembly/instructions/load/load_ind_u8 i32 (i32.const 11152)) - (global $assembly/instructions/load/load_ind_i8 i32 (i32.const 11184)) - (global $assembly/instructions/load/load_ind_u16 i32 (i32.const 11216)) - (global $assembly/instructions/load/load_ind_i16 i32 (i32.const 11248)) - (global $assembly/instructions/load/load_ind_u32 i32 (i32.const 11280)) - (global $assembly/instructions/load/load_ind_i32 i32 (i32.const 11312)) - (global $assembly/instructions/load/load_ind_u64 i32 (i32.const 11344)) - (global $assembly/instructions/mov/move_reg i32 (i32.const 11376)) - (global $assembly/instructions/mov/cmov_iz_imm i32 (i32.const 11408)) - (global $assembly/instructions/mov/cmov_nz_imm i32 (i32.const 11440)) - (global $assembly/instructions/mov/cmov_iz i32 (i32.const 11472)) - (global $assembly/instructions/mov/cmov_nz i32 (i32.const 11504)) - (global $assembly/instructions/set/set_lt_u_imm i32 (i32.const 11536)) - (global $assembly/instructions/set/set_lt_s_imm i32 (i32.const 11568)) - (global $assembly/instructions/set/set_gt_u_imm i32 (i32.const 11600)) - (global $assembly/instructions/set/set_gt_s_imm i32 (i32.const 11632)) - (global $assembly/instructions/set/set_lt_u i32 (i32.const 11664)) - (global $assembly/instructions/set/set_lt_s i32 (i32.const 11696)) - (global $assembly/instructions/shift/MAX_SHIFT_64 i32 (i32.const 64)) - (global $assembly/instructions/shift/MAX_SHIFT_32 i32 (i32.const 32)) - (global $assembly/instructions/shift/shlo_l_imm_32 i32 (i32.const 11728)) - (global $assembly/instructions/shift/shlo_r_imm_32 i32 (i32.const 11760)) - (global $assembly/instructions/shift/shar_r_imm_32 i32 (i32.const 11792)) - (global $assembly/instructions/shift/shlo_l_imm_alt_32 i32 (i32.const 11824)) - (global $assembly/instructions/shift/shlo_r_imm_alt_32 i32 (i32.const 11856)) - (global $assembly/instructions/shift/shar_r_imm_alt_32 i32 (i32.const 11888)) - (global $assembly/instructions/shift/shlo_l_imm i32 (i32.const 11920)) - (global $assembly/instructions/shift/shlo_r_imm i32 (i32.const 11952)) - (global $assembly/instructions/shift/shar_r_imm i32 (i32.const 11984)) - (global $assembly/instructions/shift/shlo_l_imm_alt i32 (i32.const 12016)) - (global $assembly/instructions/shift/shlo_r_imm_alt i32 (i32.const 12048)) - (global $assembly/instructions/shift/shar_r_imm_alt i32 (i32.const 12080)) - (global $assembly/instructions/shift/shlo_l_32 i32 (i32.const 12112)) - (global $assembly/instructions/shift/shlo_r_32 i32 (i32.const 12144)) - (global $assembly/instructions/shift/shar_r_32 i32 (i32.const 12176)) - (global $assembly/instructions/shift/shlo_l i32 (i32.const 12208)) - (global $assembly/instructions/shift/shlo_r i32 (i32.const 12240)) - (global $assembly/instructions/shift/shar_r i32 (i32.const 12272)) - (global $assembly/instructions/store/store_imm_u8 i32 (i32.const 12304)) - (global $assembly/instructions/store/store_imm_u16 i32 (i32.const 12336)) - (global $assembly/instructions/store/store_imm_u32 i32 (i32.const 12368)) - (global $assembly/instructions/store/store_imm_u64 i32 (i32.const 12400)) - (global $assembly/instructions/store/store_u8 i32 (i32.const 12432)) - (global $assembly/instructions/store/store_u16 i32 (i32.const 12464)) - (global $assembly/instructions/store/store_u32 i32 (i32.const 12496)) - (global $assembly/instructions/store/store_u64 i32 (i32.const 12528)) - (global $assembly/instructions/store/store_imm_ind_u8 i32 (i32.const 12560)) - (global $assembly/instructions/store/store_imm_ind_u16 i32 (i32.const 12592)) - (global $assembly/instructions/store/store_imm_ind_u32 i32 (i32.const 12624)) - (global $assembly/instructions/store/store_imm_ind_u64 i32 (i32.const 12656)) - (global $assembly/instructions/store/store_ind_u8 i32 (i32.const 12688)) - (global $assembly/instructions/store/store_ind_u16 i32 (i32.const 12720)) - (global $assembly/instructions/store/store_ind_u32 i32 (i32.const 12752)) - (global $assembly/instructions/store/store_ind_u64 i32 (i32.const 12784)) - (global $assembly/instructions-exe/RUN i32 (i32.const 13760)) - (global $assembly/codec/MASKS i32 (i32.const 13840)) - (global $assembly/codec/variableLength i32 (i32.const 13888)) - (global $assembly/instructions/MISSING_INSTRUCTION (mut i32) (i32.const 0)) - (global $assembly/instructions/SBRK (mut i32) (i32.const 0)) - (global $assembly/instructions/INSTRUCTIONS (mut i32) (i32.const 0)) - (global $assembly/program/MAX_SKIP i32 (i32.const 24)) - (global $assembly/program/BasicBlock.NONE i32 (i32.const 0)) - (global $assembly/program/BasicBlock.START i32 (i32.const 2)) - (global $assembly/program/BasicBlock.END i32 (i32.const 4)) - (global $assembly/program.test/TESTS (mut i32) (i32.const 0)) - (global $assembly/spi/MAX_ARGS_LEN (mut i32) (i32.const 0)) - (global $assembly/spi/ARGS_SEGMENT_START (mut i32) (i32.const 0)) - (global $assembly/spi/STACK_SEGMENT_END (mut i32) (i32.const 0)) - (global $assembly/spi.test/TESTS (mut i32) (i32.const 0)) - (global $~lib/rt/__rtti_base i32 (i32.const 27968)) - (global $~lib/memory/__data_end i32 (i32.const 28164)) - (global $~lib/memory/__stack_pointer (mut i32) (i32.const 60932)) - (global $~lib/memory/__heap_base i32 (i32.const 60932)) - (memory $0 1) - (data $0 (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00\02\00\00\00\03\00\00\00\03\00\00\00\04\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") - (data $1 (i32.const 92) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00 \00\00\00 \00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $2 (i32.const 140) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\01\00\00\00\t\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\01\00\00\00\02\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") - (data $3 (i32.const 220) ",\00\00\00\00\00\00\00\00\00\00\00\04\00\00\00\10\00\00\00\a0\00\00\00\a0\00\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $4 (i32.const 268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00A\00l\00l\00o\00c\00a\00t\00i\00o\00n\00 \00t\00o\00o\00 \00l\00a\00r\00g\00e\00\00\00\00\00") - (data $5 (i32.const 332) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00~\00l\00i\00b\00/\00r\00t\00/\00i\00t\00c\00m\00s\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $6 (i32.const 400) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $7 (i32.const 432) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $8 (i32.const 460) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00I\00n\00d\00e\00x\00 \00o\00u\00t\00 \00o\00f\00 \00r\00a\00n\00g\00e\00\00\00\00\00\00\00\00\00") - (data $9 (i32.const 524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00~\00l\00i\00b\00/\00r\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $10 (i32.const 576) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $11 (i32.const 604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00~\00l\00i\00b\00/\00r\00t\00/\00t\00l\00s\00f\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $12 (i32.const 668) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00") - (data $13 (i32.const 700) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00~\00l\00i\00b\00/\00t\00y\00p\00e\00d\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $14 (i32.const 764) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00") - (data $15 (i32.const 796) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\03\00\00\00\00\00\00\00\00\00\00\00") - (data $16 (i32.const 828) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\04\00\00\00\00\00\00\00\00\00\00\00") - (data $17 (i32.const 860) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\05\00\00\00\00\00\00\00\00\00\00\00") - (data $18 (i32.const 892) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\06\00\00\00\00\00\00\00\00\00\00\00") - (data $19 (i32.const 924) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\07\00\00\00\00\00\00\00\00\00\00\00") - (data $20 (i32.const 956) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00") - (data $21 (i32.const 988) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\t\00\00\00\00\00\00\00\00\00\00\00") - (data $22 (i32.const 1020) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\n\00\00\00\00\00\00\00\00\00\00\00") - (data $23 (i32.const 1052) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0b\00\00\00\00\00\00\00\00\00\00\00") - (data $24 (i32.const 1084) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\0c\00\00\00\00\00\00\00\00\00\00\00") - (data $25 (i32.const 1116) "\1c\00\00\00\00\00\00\00\00\00\00\00\08\00\00\00\08\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00") - (data $26 (i32.const 1148) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\004\00\00\00\b0\02\00\00\10\03\00\000\03\00\00P\03\00\00p\03\00\00\90\03\00\00\b0\03\00\00\d0\03\00\00\f0\03\00\00\10\04\00\000\04\00\00P\04\00\00p\04\00\00\00\00\00\00\00\00\00\00") - (data $27 (i32.const 1228) ",\00\00\00\00\00\00\00\00\00\00\00\07\00\00\00\10\00\00\00\90\04\00\00\90\04\00\004\00\00\00\r\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $28 (i32.const 1276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00I\00n\00v\00a\00l\00i\00d\00 \00l\00e\00n\00g\00t\00h\00") - (data $29 (i32.const 1324) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00b\00u\00f\00f\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") - (data $30 (i32.const 1388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00s\00t\00a\00t\00i\00c\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00\00\00\00\00") - (data $31 (i32.const 1452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\0e\00\00\00\00\00\00\00\00\00\00\00") - (data $32 (i32.const 1484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\0f\00\00\00\00\00\00\00\00\00\00\00") - (data $33 (i32.const 1516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\10\00\00\00\00\00\00\00\00\00\00\00") - (data $34 (i32.const 1548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\11\00\00\00\00\00\00\00\00\00\00\00") - (data $35 (i32.const 1580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\12\00\00\00\00\00\00\00\00\00\00\00") - (data $36 (i32.const 1612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\13\00\00\00\00\00\00\00\00\00\00\00") - (data $37 (i32.const 1644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\14\00\00\00\00\00\00\00\00\00\00\00") - (data $38 (i32.const 1676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\15\00\00\00\00\00\00\00\00\00\00\00") - (data $39 (i32.const 1708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\16\00\00\00\00\00\00\00\00\00\00\00") - (data $40 (i32.const 1740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\17\00\00\00\00\00\00\00\00\00\00\00") - (data $41 (i32.const 1772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00c\00o\00u\00n\00t\00_\00s\00e\00t\00_\00b\00i\00t\00s\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $42 (i32.const 1836) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $43 (i32.const 1868) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00~\00l\00i\00b\00/\00a\00r\00r\00a\00y\00.\00t\00s\00\00\00") - (data $44 (i32.const 1916) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00s\00b\00r\00k\00 \00w\00i\00t\00h\00i\00n\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00m\00e\00m\00o\00r\00y\00 \00i\00s\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00e\00d\00!\00\00\00\00\00\00\00") - (data $45 (i32.const 2028) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $46 (i32.const 2092) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $47 (i32.const 2124) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00o\00u\00t\00c\00o\00m\00e\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $48 (i32.const 2172) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00(\000\00x\00\00\00\00\00") - (data $49 (i32.const 2204) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") - (data $50 (i32.const 2236) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $51 (i32.const 2284) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00d\00\00\00t\00o\00S\00t\00r\00i\00n\00g\00(\00)\00 \00r\00a\00d\00i\00x\00 \00a\00r\00g\00u\00m\00e\00n\00t\00 \00m\00u\00s\00t\00 \00b\00e\00 \00b\00e\00t\00w\00e\00e\00n\00 \002\00 \00a\00n\00d\00 \003\006\00\00\00\00\00\00\00\00\00") - (data $52 (i32.const 2412) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00&\00\00\00~\00l\00i\00b\00/\00u\00t\00i\00l\00/\00n\00u\00m\00b\00e\00r\00.\00t\00s\00\00\00\00\00\00\00") - (data $53 (i32.const 2476) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\000\00\00\00\00\00\00\00\00\00\00\00") - (data $54 (i32.const 2508) "0\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\00") - (data $55 (i32.const 2908) "\1c\04\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\04\00\000\000\000\001\000\002\000\003\000\004\000\005\000\006\000\007\000\008\000\009\000\00a\000\00b\000\00c\000\00d\000\00e\000\00f\001\000\001\001\001\002\001\003\001\004\001\005\001\006\001\007\001\008\001\009\001\00a\001\00b\001\00c\001\00d\001\00e\001\00f\002\000\002\001\002\002\002\003\002\004\002\005\002\006\002\007\002\008\002\009\002\00a\002\00b\002\00c\002\00d\002\00e\002\00f\003\000\003\001\003\002\003\003\003\004\003\005\003\006\003\007\003\008\003\009\003\00a\003\00b\003\00c\003\00d\003\00e\003\00f\004\000\004\001\004\002\004\003\004\004\004\005\004\006\004\007\004\008\004\009\004\00a\004\00b\004\00c\004\00d\004\00e\004\00f\005\000\005\001\005\002\005\003\005\004\005\005\005\006\005\007\005\008\005\009\005\00a\005\00b\005\00c\005\00d\005\00e\005\00f\006\000\006\001\006\002\006\003\006\004\006\005\006\006\006\007\006\008\006\009\006\00a\006\00b\006\00c\006\00d\006\00e\006\00f\007\000\007\001\007\002\007\003\007\004\007\005\007\006\007\007\007\008\007\009\007\00a\007\00b\007\00c\007\00d\007\00e\007\00f\008\000\008\001\008\002\008\003\008\004\008\005\008\006\008\007\008\008\008\009\008\00a\008\00b\008\00c\008\00d\008\00e\008\00f\009\000\009\001\009\002\009\003\009\004\009\005\009\006\009\007\009\008\009\009\009\00a\009\00b\009\00c\009\00d\009\00e\009\00f\00a\000\00a\001\00a\002\00a\003\00a\004\00a\005\00a\006\00a\007\00a\008\00a\009\00a\00a\00a\00b\00a\00c\00a\00d\00a\00e\00a\00f\00b\000\00b\001\00b\002\00b\003\00b\004\00b\005\00b\006\00b\007\00b\008\00b\009\00b\00a\00b\00b\00b\00c\00b\00d\00b\00e\00b\00f\00c\000\00c\001\00c\002\00c\003\00c\004\00c\005\00c\006\00c\007\00c\008\00c\009\00c\00a\00c\00b\00c\00c\00c\00d\00c\00e\00c\00f\00d\000\00d\001\00d\002\00d\003\00d\004\00d\005\00d\006\00d\007\00d\008\00d\009\00d\00a\00d\00b\00d\00c\00d\00d\00d\00e\00d\00f\00e\000\00e\001\00e\002\00e\003\00e\004\00e\005\00e\006\00e\007\00e\008\00e\009\00e\00a\00e\00b\00e\00c\00e\00d\00e\00e\00e\00f\00f\000\00f\001\00f\002\00f\003\00f\004\00f\005\00f\006\00f\007\00f\008\00f\009\00f\00a\00f\00b\00f\00c\00f\00d\00f\00e\00f\00f\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $56 (i32.const 3964) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00H\00\00\000\001\002\003\004\005\006\007\008\009\00a\00b\00c\00d\00e\00f\00g\00h\00i\00j\00k\00l\00m\00n\00o\00p\00q\00r\00s\00t\00u\00v\00w\00x\00y\00z\00\00\00\00\00") - (data $57 (i32.const 4060) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $58 (i32.const 4092) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $59 (i32.const 4140) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00G\00o\00t\00:\00 \00\'\00") - (data $60 (i32.const 4172) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00\'\00,\00 \00e\00x\00p\00e\00c\00t\00e\00d\00:\00 \00\'\00") - (data $61 (i32.const 4220) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00\'\00 \00@\00 \00\00\00\00\00") - (data $62 (i32.const 4252) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $63 (i32.const 4300) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $64 (i32.const 4348) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $65 (i32.const 4396) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $66 (i32.const 4444) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\18\00\00\00\00\00\00\00\00\00\00\00") - (data $67 (i32.const 4476) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00c\00o\00u\00n\00t\00_\00s\00e\00t\00_\00b\00i\00t\00s\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $68 (i32.const 4540) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\19\00\00\00\00\00\00\00\00\00\00\00") - (data $69 (i32.const 4572) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00l\00e\00a\00d\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\006\004\00\00\00\00\00") - (data $70 (i32.const 4636) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1a\00\00\00\00\00\00\00\00\00\00\00") - (data $71 (i32.const 4668) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00l\00e\00a\00d\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\003\002\00\00\00\00\00") - (data $72 (i32.const 4732) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1b\00\00\00\00\00\00\00\00\00\00\00") - (data $73 (i32.const 4764) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00t\00r\00a\00i\00l\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\006\004\00\00\00") - (data $74 (i32.const 4828) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1c\00\00\00\00\00\00\00\00\00\00\00") - (data $75 (i32.const 4860) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00t\00r\00a\00i\00l\00i\00n\00g\00_\00z\00e\00r\00o\00_\00b\00i\00t\00s\00_\003\002\00\00\00") - (data $76 (i32.const 4924) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1d\00\00\00\00\00\00\00\00\00\00\00") - (data $77 (i32.const 4956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00s\00i\00g\00n\00_\00e\00x\00t\00e\00n\00d\00_\008\00\00\00") - (data $78 (i32.const 5004) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1e\00\00\00\00\00\00\00\00\00\00\00") - (data $79 (i32.const 5036) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00s\00i\00g\00n\00_\00e\00x\00t\00e\00n\00d\00_\001\006\00") - (data $80 (i32.const 5084) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\1f\00\00\00\00\00\00\00\00\00\00\00") - (data $81 (i32.const 5116) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00z\00e\00r\00o\00_\00e\00x\00t\00e\00n\00d\00_\001\006\00") - (data $82 (i32.const 5164) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $83 (i32.const 5196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00r\00e\00v\00e\00r\00s\00e\00_\00b\00y\00t\00e\00s\00\00\00") - (data $84 (i32.const 5244) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $85 (i32.const 5292) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $86 (i32.const 5340) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $87 (i32.const 5388) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00!\00\00\00\00\00\00\00\00\00\00\00") - (data $88 (i32.const 5420) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\"\00\00\00\00\00\00\00\00\00\00\00") - (data $89 (i32.const 5452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00#\00\00\00\00\00\00\00\00\00\00\00") - (data $90 (i32.const 5484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00$\00\00\00\00\00\00\00\00\00\00\00") - (data $91 (i32.const 5516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00%\00\00\00\00\00\00\00\00\00\00\00") - (data $92 (i32.const 5548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00&\00\00\00\00\00\00\00\00\00\00\00") - (data $93 (i32.const 5580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\'\00\00\00\00\00\00\00\00\00\00\00") - (data $94 (i32.const 5612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00(\00\00\00\00\00\00\00\00\00\00\00") - (data $95 (i32.const 5644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00)\00\00\00\00\00\00\00\00\00\00\00") - (data $96 (i32.const 5676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00*\00\00\00\00\00\00\00\00\00\00\00") - (data $97 (i32.const 5708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00+\00\00\00\00\00\00\00\00\00\00\00") - (data $98 (i32.const 5740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") - (data $99 (i32.const 5772) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00-\00\00\00\00\00\00\00\00\00\00\00") - (data $100 (i32.const 5804) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00.\00\00\00\00\00\00\00\00\00\00\00") - (data $101 (i32.const 5836) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00/\00\00\00\00\00\00\00\00\00\00\00") - (data $102 (i32.const 5868) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\000\00\00\00\00\00\00\00\00\00\00\00") - (data $103 (i32.const 5900) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\001\00\00\00\00\00\00\00\00\00\00\00") - (data $104 (i32.const 5932) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00b\00r\00a\00n\00c\00h\00_\00e\00q\00_\00i\00m\00m\00\00\00") - (data $105 (i32.const 5980) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00s\00t\00a\00t\00i\00c\00J\00u\00m\00p\00\00\00\00\00\00\00\00\00") - (data $106 (i32.const 6028) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $107 (i32.const 6076) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $108 (i32.const 6124) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $109 (i32.const 6172) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\002\00\00\00\00\00\00\00\00\00\00\00") - (data $110 (i32.const 6204) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\003\00\00\00\00\00\00\00\00\00\00\00") - (data $111 (i32.const 6236) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\004\00\00\00\00\00\00\00\00\00\00\00") - (data $112 (i32.const 6268) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\005\00\00\00\00\00\00\00\00\00\00\00") - (data $113 (i32.const 6300) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\006\00\00\00\00\00\00\00\00\00\00\00") - (data $114 (i32.const 6332) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\007\00\00\00\00\00\00\00\00\00\00\00") - (data $115 (i32.const 6364) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\008\00\00\00\00\00\00\00\00\00\00\00") - (data $116 (i32.const 6396) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\009\00\00\00\00\00\00\00\00\00\00\00") - (data $117 (i32.const 6428) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00:\00\00\00\00\00\00\00\00\00\00\00") - (data $118 (i32.const 6460) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00;\00\00\00\00\00\00\00\00\00\00\00") - (data $119 (i32.const 6492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00a\00n\00d\00_\00i\00n\00v\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $120 (i32.const 6540) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00<\00\00\00\00\00\00\00\00\00\00\00") - (data $121 (i32.const 6572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00o\00r\00_\00i\00n\00v\00") - (data $122 (i32.const 6604) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00=\00\00\00\00\00\00\00\00\00\00\00") - (data $123 (i32.const 6636) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00x\00n\00o\00r\00\00\00\00\00") - (data $124 (i32.const 6668) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00>\00\00\00\00\00\00\00\00\00\00\00") - (data $125 (i32.const 6700) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00?\00\00\00\00\00\00\00\00\00\00\00") - (data $126 (i32.const 6732) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00@\00\00\00\00\00\00\00\00\00\00\00") - (data $127 (i32.const 6764) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00A\00\00\00\00\00\00\00\00\00\00\00") - (data $128 (i32.const 6796) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00B\00\00\00\00\00\00\00\00\00\00\00") - (data $129 (i32.const 6828) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00C\00\00\00\00\00\00\00\00\00\00\00") - (data $130 (i32.const 6860) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00D\00\00\00\00\00\00\00\00\00\00\00") - (data $131 (i32.const 6892) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00E\00\00\00\00\00\00\00\00\00\00\00") - (data $132 (i32.const 6924) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00F\00\00\00\00\00\00\00\00\00\00\00") - (data $133 (i32.const 6956) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00G\00\00\00\00\00\00\00\00\00\00\00") - (data $134 (i32.const 6988) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00H\00\00\00\00\00\00\00\00\00\00\00") - (data $135 (i32.const 7020) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00I\00\00\00\00\00\00\00\00\00\00\00") - (data $136 (i32.const 7052) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00J\00\00\00\00\00\00\00\00\00\00\00") - (data $137 (i32.const 7084) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00K\00\00\00\00\00\00\00\00\00\00\00") - (data $138 (i32.const 7116) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00L\00\00\00\00\00\00\00\00\00\00\00") - (data $139 (i32.const 7148) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00M\00\00\00\00\00\00\00\00\00\00\00") - (data $140 (i32.const 7180) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00N\00\00\00\00\00\00\00\00\00\00\00") - (data $141 (i32.const 7212) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00O\00\00\00\00\00\00\00\00\00\00\00") - (data $142 (i32.const 7244) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00P\00\00\00\00\00\00\00\00\00\00\00") - (data $143 (i32.const 7276) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00Q\00\00\00\00\00\00\00\00\00\00\00") - (data $144 (i32.const 7308) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00R\00\00\00\00\00\00\00\00\00\00\00") - (data $145 (i32.const 7340) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00S\00\00\00\00\00\00\00\00\00\00\00") - (data $146 (i32.const 7372) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00T\00\00\00\00\00\00\00\00\00\00\00") - (data $147 (i32.const 7404) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00U\00\00\00\00\00\00\00\00\00\00\00") - (data $148 (i32.const 7436) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00V\00\00\00\00\00\00\00\00\00\00\00") - (data $149 (i32.const 7468) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00W\00\00\00\00\00\00\00\00\00\00\00") - (data $150 (i32.const 7500) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00X\00\00\00\00\00\00\00\00\00\00\00") - (data $151 (i32.const 7532) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00Y\00\00\00\00\00\00\00\00\00\00\00") - (data $152 (i32.const 7564) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00m\00a\00x\00\00\00\00\00\00\00") - (data $153 (i32.const 7596) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00Z\00\00\00\00\00\00\00\00\00\00\00") - (data $154 (i32.const 7628) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00m\00a\00x\00_\00u\00\00\00") - (data $155 (i32.const 7660) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00[\00\00\00\00\00\00\00\00\00\00\00") - (data $156 (i32.const 7692) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00m\00i\00n\00\00\00\00\00\00\00") - (data $157 (i32.const 7724) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\\\00\00\00\00\00\00\00\00\00\00\00") - (data $158 (i32.const 7756) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00m\00i\00n\00_\00u\00\00\00") - (data $159 (i32.const 7788) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") - (data $160 (i32.const 7820) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00a\00d\00d\00_\003\002\00") - (data $161 (i32.const 7852) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00^\00\00\00\00\00\00\00\00\00\00\00") - (data $162 (i32.const 7884) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00_\00\00\00\00\00\00\00\00\00\00\00") - (data $163 (i32.const 7916) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00`\00\00\00\00\00\00\00\00\00\00\00") - (data $164 (i32.const 7948) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") - (data $165 (i32.const 7980) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") - (data $166 (i32.const 8012) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") - (data $167 (i32.const 8044) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") - (data $168 (i32.const 8076) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00e\00\00\00\00\00\00\00\00\00\00\00") - (data $169 (i32.const 8108) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00f\00\00\00\00\00\00\00\00\00\00\00") - (data $170 (i32.const 8140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00r\00o\00t\00_\00r\00_\006\004\00_\00i\00m\00m\00\00\00\00\00") - (data $171 (i32.const 8188) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00g\00\00\00\00\00\00\00\00\00\00\00") - (data $172 (i32.const 8220) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00r\00o\00t\00_\00r\00_\006\004\00_\00i\00m\00m\00_\00a\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $173 (i32.const 8284) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00h\00\00\00\00\00\00\00\00\00\00\00") - (data $174 (i32.const 8316) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00r\00o\00t\00_\00l\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $175 (i32.const 8364) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00i\00\00\00\00\00\00\00\00\00\00\00") - (data $176 (i32.const 8396) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00r\00o\00t\00_\00l\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $177 (i32.const 8444) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00j\00\00\00\00\00\00\00\00\00\00\00") - (data $178 (i32.const 8476) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00h\00\00\00S\00h\00o\00w\00 \00f\00a\00i\00l\00 \00w\00h\00e\00n\00 \00a\00c\00c\00e\00s\00s\00i\00n\00g\00 \00a\00n\00y\00 \00o\00f\00 \00t\00h\00e\00 \00i\00n\00i\00t\00i\00a\00l\00 \001\006\00 \00p\00a\00g\00e\00s\00\00\00\00\00") - (data $179 (i32.const 8604) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00K\00e\00y\00 \00d\00o\00e\00s\00 \00n\00o\00t\00 \00e\00x\00i\00s\00t\00\00\00\00\00\00\00\00\00") - (data $180 (i32.const 8668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00~\00l\00i\00b\00/\00m\00a\00p\00.\00t\00s\00\00\00\00\00\00\00") - (data $181 (i32.const 8716) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00U\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00\'\00n\00u\00l\00l\00\'\00 \00(\00n\00o\00t\00 \00a\00s\00s\00i\00g\00n\00e\00d\00 \00o\00r\00 \00f\00a\00i\00l\00e\00d\00 \00c\00a\00s\00t\00)\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $182 (i32.const 8844) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00.\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00m\00e\00m\00o\00r\00y\00-\00p\00a\00g\00e\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $183 (i32.const 8924) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00a\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $184 (i32.const 8972) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $185 (i32.const 9020) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00t\00r\00u\00e\00\00\00\00\00") - (data $186 (i32.const 9052) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00f\00a\00l\00s\00e\00\00\00") - (data $187 (i32.const 9084) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00\90\08\00\00\00\00\00\00\b0\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $188 (i32.const 9132) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $189 (i32.const 9180) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00a\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $190 (i32.const 9228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00b\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $191 (i32.const 9276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00b\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $192 (i32.const 9324) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00k\00\00\00\00\00\00\00\00\00\00\00") - (data $193 (i32.const 9356) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00V\00\00\00S\00h\00o\00w\00 \00f\00a\00i\00l\00 \00o\00n\00 \00m\00i\00s\00s\00i\00n\00g\00 \00p\00a\00g\00e\00 \00o\00r\00 \00i\00n\00v\00a\00l\00i\00d\00 \00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00") - (data $194 (i32.const 9468) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00A\00t\00t\00e\00m\00p\00t\00i\00n\00g\00 \00t\00o\00 \00a\00l\00l\00o\00c\00a\00t\00e\00 \00r\00e\00s\00e\00r\00v\00e\00d\00 \00p\00a\00g\00e\00:\00 \00") - (data $195 (i32.const 9564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00A\00r\00r\00a\00y\00 \00i\00s\00 \00e\00m\00p\00t\00y\00") - (data $196 (i32.const 9612) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00W\00a\00r\00n\00i\00n\00g\00:\00 \00R\00u\00n\00 \00o\00u\00t\00 \00o\00f\00 \00p\00a\00g\00e\00s\00!\00 \00A\00l\00l\00o\00c\00a\00t\00i\00n\00g\00.\00") - (data $197 (i32.const 9708) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00c\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $198 (i32.const 9756) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00c\00.\00a\00c\00c\00e\00s\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $199 (i32.const 9804) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00l\00\00\00\00\00\00\00\00\00\00\00") - (data $200 (i32.const 9836) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00s\00h\00o\00u\00l\00d\00 \00r\00e\00a\00d\00 \00a\00n\00d\00 \00w\00r\00i\00t\00e\00 \00a\00c\00r\00o\00s\00s\00 \00p\00a\00g\00e\00s\00\00\00\00\00\00\00\00\00") - (data $201 (i32.const 9932) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\10\00\00\00\de\00\00\00\ad\00\00\00\be\00\00\00\ef\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $202 (i32.const 9980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00,\00\00\00\00\00\00\00\00\00\00\00") - (data $203 (i32.const 10012) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00J\00\00\001\007\003\00,\001\009\000\00,\002\003\009\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00\00\00") - (data $204 (i32.const 10108) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\18\00\00\00@\10\00\00\00\00\00\00`\10\00\00\00\00\00\00\90\10\00\00\00\00\00\00\00\00\00\00") - (data $205 (i32.const 10156) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00N\00\00\002\002\002\00,\001\007\003\00,\001\009\000\00,\002\003\009\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00,\000\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $206 (i32.const 10268) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00m\00\00\00\00\00\00\00\00\00\00\00") - (data $207 (i32.const 10300) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00`\00\00\00s\00h\00o\00u\00l\00d\00 \00a\00l\00l\00o\00w\00 \000\00-\00b\00y\00t\00e\00s\00 \00r\00e\00a\00d\00s\00 \00a\00n\00d\00 \00w\00r\00i\00t\00e\00s\00 \00e\00v\00e\00r\00y\00w\00h\00e\00r\00e\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $208 (i32.const 10428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00d\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $209 (i32.const 10476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00e\00.\00f\00a\00u\00l\00t\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $210 (i32.const 10524) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00n\00\00\00\00\00\00\00\00\00\00\00") - (data $211 (i32.const 10556) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00o\00\00\00\00\00\00\00\00\00\00\00") - (data $212 (i32.const 10588) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00p\00\00\00\00\00\00\00\00\00\00\00") - (data $213 (i32.const 10620) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00q\00\00\00\00\00\00\00\00\00\00\00") - (data $214 (i32.const 10652) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00r\00\00\00\00\00\00\00\00\00\00\00") - (data $215 (i32.const 10684) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $216 (i32.const 10716) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00t\00\00\00\00\00\00\00\00\00\00\00") - (data $217 (i32.const 10748) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00u\00\00\00\00\00\00\00\00\00\00\00") - (data $218 (i32.const 10780) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00v\00\00\00\00\00\00\00\00\00\00\00") - (data $219 (i32.const 10812) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00w\00\00\00\00\00\00\00\00\00\00\00") - (data $220 (i32.const 10844) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00x\00\00\00\00\00\00\00\00\00\00\00") - (data $221 (i32.const 10876) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00y\00\00\00\00\00\00\00\00\00\00\00") - (data $222 (i32.const 10908) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00z\00\00\00\00\00\00\00\00\00\00\00") - (data $223 (i32.const 10940) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00{\00\00\00\00\00\00\00\00\00\00\00") - (data $224 (i32.const 10972) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00|\00\00\00\00\00\00\00\00\00\00\00") - (data $225 (i32.const 11004) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00}\00\00\00\00\00\00\00\00\00\00\00") - (data $226 (i32.const 11036) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00~\00\00\00\00\00\00\00\00\00\00\00") - (data $227 (i32.const 11068) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\7f\00\00\00\00\00\00\00\00\00\00\00") - (data $228 (i32.const 11100) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\80\00\00\00\00\00\00\00\00\00\00\00") - (data $229 (i32.const 11132) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\81\00\00\00\00\00\00\00\00\00\00\00") - (data $230 (i32.const 11164) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\82\00\00\00\00\00\00\00\00\00\00\00") - (data $231 (i32.const 11196) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\83\00\00\00\00\00\00\00\00\00\00\00") - (data $232 (i32.const 11228) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\84\00\00\00\00\00\00\00\00\00\00\00") - (data $233 (i32.const 11260) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\85\00\00\00\00\00\00\00\00\00\00\00") - (data $234 (i32.const 11292) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\86\00\00\00\00\00\00\00\00\00\00\00") - (data $235 (i32.const 11324) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\87\00\00\00\00\00\00\00\00\00\00\00") - (data $236 (i32.const 11356) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\88\00\00\00\00\00\00\00\00\00\00\00") - (data $237 (i32.const 11388) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\89\00\00\00\00\00\00\00\00\00\00\00") - (data $238 (i32.const 11420) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8a\00\00\00\00\00\00\00\00\00\00\00") - (data $239 (i32.const 11452) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8b\00\00\00\00\00\00\00\00\00\00\00") - (data $240 (i32.const 11484) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8c\00\00\00\00\00\00\00\00\00\00\00") - (data $241 (i32.const 11516) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8d\00\00\00\00\00\00\00\00\00\00\00") - (data $242 (i32.const 11548) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8e\00\00\00\00\00\00\00\00\00\00\00") - (data $243 (i32.const 11580) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\8f\00\00\00\00\00\00\00\00\00\00\00") - (data $244 (i32.const 11612) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\90\00\00\00\00\00\00\00\00\00\00\00") - (data $245 (i32.const 11644) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\91\00\00\00\00\00\00\00\00\00\00\00") - (data $246 (i32.const 11676) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\92\00\00\00\00\00\00\00\00\00\00\00") - (data $247 (i32.const 11708) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\93\00\00\00\00\00\00\00\00\00\00\00") - (data $248 (i32.const 11740) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\94\00\00\00\00\00\00\00\00\00\00\00") - (data $249 (i32.const 11772) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\95\00\00\00\00\00\00\00\00\00\00\00") - (data $250 (i32.const 11804) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\96\00\00\00\00\00\00\00\00\00\00\00") - (data $251 (i32.const 11836) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\97\00\00\00\00\00\00\00\00\00\00\00") - (data $252 (i32.const 11868) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\98\00\00\00\00\00\00\00\00\00\00\00") - (data $253 (i32.const 11900) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\99\00\00\00\00\00\00\00\00\00\00\00") - (data $254 (i32.const 11932) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9a\00\00\00\00\00\00\00\00\00\00\00") - (data $255 (i32.const 11964) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9b\00\00\00\00\00\00\00\00\00\00\00") - (data $256 (i32.const 11996) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9c\00\00\00\00\00\00\00\00\00\00\00") - (data $257 (i32.const 12028) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9d\00\00\00\00\00\00\00\00\00\00\00") - (data $258 (i32.const 12060) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9e\00\00\00\00\00\00\00\00\00\00\00") - (data $259 (i32.const 12092) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\9f\00\00\00\00\00\00\00\00\00\00\00") - (data $260 (i32.const 12124) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a0\00\00\00\00\00\00\00\00\00\00\00") - (data $261 (i32.const 12156) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a1\00\00\00\00\00\00\00\00\00\00\00") - (data $262 (i32.const 12188) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a2\00\00\00\00\00\00\00\00\00\00\00") - (data $263 (i32.const 12220) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a3\00\00\00\00\00\00\00\00\00\00\00") - (data $264 (i32.const 12252) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a4\00\00\00\00\00\00\00\00\00\00\00") - (data $265 (i32.const 12284) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a5\00\00\00\00\00\00\00\00\00\00\00") - (data $266 (i32.const 12316) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a6\00\00\00\00\00\00\00\00\00\00\00") - (data $267 (i32.const 12348) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a7\00\00\00\00\00\00\00\00\00\00\00") - (data $268 (i32.const 12380) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a8\00\00\00\00\00\00\00\00\00\00\00") - (data $269 (i32.const 12412) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\a9\00\00\00\00\00\00\00\00\00\00\00") - (data $270 (i32.const 12444) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\aa\00\00\00\00\00\00\00\00\00\00\00") - (data $271 (i32.const 12476) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ab\00\00\00\00\00\00\00\00\00\00\00") - (data $272 (i32.const 12508) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ac\00\00\00\00\00\00\00\00\00\00\00") - (data $273 (i32.const 12540) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ad\00\00\00\00\00\00\00\00\00\00\00") - (data $274 (i32.const 12572) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\ae\00\00\00\00\00\00\00\00\00\00\00") - (data $275 (i32.const 12604) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\af\00\00\00\00\00\00\00\00\00\00\00") - (data $276 (i32.const 12636) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b0\00\00\00\00\00\00\00\00\00\00\00") - (data $277 (i32.const 12668) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b1\00\00\00\00\00\00\00\00\00\00\00") - (data $278 (i32.const 12700) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b2\00\00\00\00\00\00\00\00\00\00\00") - (data $279 (i32.const 12732) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b3\00\00\00\00\00\00\00\00\00\00\00") - (data $280 (i32.const 12764) "\1c\00\00\00\00\00\00\00\00\00\00\00\13\00\00\00\08\00\00\00\b4\00\00\00\00\00\00\00\00\00\00\00") - (data $281 (i32.const 12796) "\ac\03\00\00\00\00\00\00\00\00\00\00\01\00\00\00\9c\03\00\00\f0)\00\00\10*\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\000*\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00p*\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\100\00\0000\00\00P0\00\00p0\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00P)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00p)\00\00\90*\00\00\b0*\00\00\d0*\00\00\f0*\00\00\10+\00\000+\00\00P+\00\00p+\00\00\900\00\00\b00\00\00\d00\00\00\f00\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\101\00\0001\00\00P1\00\00p1\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\90)\00\00@\15\00\00`\15\00\00\80\15\00\00\a0\15\00\00\c0\15\00\00\e0\15\00\00\00\16\00\00 \16\00\00@\16\00\00`\16\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00p,\00\00P*\00\00\c0\05\00\00\e0\05\00\00\00\06\00\00 \06\00\00@\06\00\00`\06\00\00\80\06\00\00\a0\06\00\00\c0\06\00\00\e0\06\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\901\00\00\b01\00\00\d01\00\00\f01\00\00\90+\00\00\b0+\00\00\d0+\00\00\f0+\00\00\10,\00\000,\00\00P,\00\00@\1a\00\00P\18\00\00p\18\00\00\90\18\00\00`\1a\00\00\10-\00\000-\00\00\d0-\00\00\f0-\00\00\10.\00\00\80\1a\00\00P-\00\00p-\00\000.\00\00P.\00\00p.\00\00\90,\00\00\b0,\00\00\a0\1a\00\00\c0\1a\00\00\90.\00\00\b0.\00\00\d0.\00\00\e0\1a\00\00\f0.\00\00\10/\00\000/\00\00\e0\1e\00\00\00\1f\00\00 \1f\00\00@\1f\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\80\16\00\00\a0\16\00\00\c0\16\00\00\e0\16\00\00\00\17\00\00 \17\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\b0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\d0)\00\00\00\1b\00\00 \1b\00\00@\1b\00\00`\1b\00\00\80\1b\00\00\a0\1b\00\00\c0\1b\00\00P/\00\00p/\00\00\90/\00\00\e0\1b\00\00\00\1c\00\00 \1c\00\00@\1c\00\00`\1c\00\00\80\1c\00\00\a0\1c\00\00\b0/\00\00\d0/\00\00\f0/\00\00\b0\18\00\00\d0\18\00\00\f0\18\00\00\c0\1c\00\00\e0\1c\00\00\00\1d\00\00\90-\00\00\b0-\00\00\d0,\00\00\f0,\00\00`\1f\00\00\80\1f\00\00\a0\1f\00\00\c0\1f\00\00\10\19\00\000\19\00\00P\19\00\00 \1d\00\00@\1d\00\00`\1d\00\00\80\1d\00\00") - (data $282 (i32.const 13740) ",\00\00\00\00\00\00\00\00\00\00\00!\00\00\00\10\00\00\00\102\00\00\102\00\00\9c\03\00\00\e7\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $283 (i32.const 13788) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\08\00\00\00\ff\fe\fc\f8\f0\e0\c0\80\00\00\00\00") - (data $284 (i32.const 13820) ",\00\00\00\00\00\00\00\00\00\00\00\"\00\00\00\10\00\00\00\f05\00\00\f05\00\00\08\00\00\00\08\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $285 (i32.const 13868) "\1c\00\00\00\00\00\00\00\00\00\00\00#\00\00\00\08\00\00\00\b5\00\00\00\00\00\00\00\00\00\00\00") - (data $286 (i32.const 13900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00I\00N\00V\00A\00L\00I\00D\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $287 (i32.const 13948) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00S\00B\00R\00K\00\00\00\00\00") - (data $288 (i32.const 13980) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00T\00R\00A\00P\00\00\00\00\00") - (data $289 (i32.const 14012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00F\00A\00L\00L\00T\00H\00R\00O\00U\00G\00H\00\00\00\00\00\00\00") - (data $290 (i32.const 14060) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00E\00C\00A\00L\00L\00I\00") - (data $291 (i32.const 14092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00") - (data $292 (i32.const 14140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\008\00\00\00\00\00") - (data $293 (i32.const 14188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\001\006\00\00\00") - (data $294 (i32.const 14236) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\003\002\00\00\00") - (data $295 (i32.const 14284) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00U\006\004\00\00\00") - (data $296 (i32.const 14332) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00J\00U\00M\00P\00\00\00\00\00") - (data $297 (i32.const 14364) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $298 (i32.const 14412) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $299 (i32.const 14460) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $300 (i32.const 14508) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00L\00O\00A\00D\00_\00I\008\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $301 (i32.const 14556) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $302 (i32.const 14604) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\001\006\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $303 (i32.const 14652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $304 (i32.const 14700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00I\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $305 (i32.const 14748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00L\00O\00A\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $306 (i32.const 14796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00T\00O\00R\00E\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $307 (i32.const 14844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") - (data $308 (i32.const 14892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $309 (i32.const 14940) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00T\00O\00R\00E\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $310 (i32.const 14988) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $311 (i32.const 15052) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00\00\00\00\00\00\00") - (data $312 (i32.const 15116) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $313 (i32.const 15180) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00T\00O\00R\00E\00_\00I\00M\00M\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $314 (i32.const 15244) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00\00\00") - (data $315 (i32.const 15292) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00_\00I\00M\00M\00\00\00") - (data $316 (i32.const 15340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00_\00I\00M\00M\00\00\00") - (data $317 (i32.const 15388) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $318 (i32.const 15452) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $319 (i32.const 15516) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $320 (i32.const 15580) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $321 (i32.const 15644) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $322 (i32.const 15708) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $323 (i32.const 15772) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $324 (i32.const 15836) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $325 (i32.const 15900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00M\00O\00V\00E\00_\00R\00E\00G\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $326 (i32.const 15948) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $327 (i32.const 16012) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00C\00O\00U\00N\00T\00_\00S\00E\00T\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $328 (i32.const 16076) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00\00\00") - (data $329 (i32.const 16140) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00L\00E\00A\00D\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00\00\00") - (data $330 (i32.const 16204) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\006\004\00\00\00") - (data $331 (i32.const 16268) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00T\00R\00A\00I\00L\00I\00N\00G\00_\00Z\00E\00R\00O\00_\00B\00I\00T\00S\00_\003\002\00\00\00") - (data $332 (i32.const 16332) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\008\00\00\00") - (data $333 (i32.const 16380) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00S\00I\00G\00N\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") - (data $334 (i32.const 16428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00Z\00E\00R\00O\00_\00E\00X\00T\00E\00N\00D\00_\001\006\00") - (data $335 (i32.const 16476) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00R\00E\00V\00E\00R\00S\00E\00_\00B\00Y\00T\00E\00S\00\00\00") - (data $336 (i32.const 16524) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00") - (data $337 (i32.const 16572) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\001\006\00\00\00") - (data $338 (i32.const 16620) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\003\002\00\00\00") - (data $339 (i32.const 16668) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00T\00O\00R\00E\00_\00I\00N\00D\00_\00U\006\004\00\00\00") - (data $340 (i32.const 16716) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\008\00\00\00\00\00\00\00") - (data $341 (i32.const 16764) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\008\00\00\00\00\00\00\00") - (data $342 (i32.const 16812) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\001\006\00\00\00\00\00") - (data $343 (i32.const 16860) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\001\006\00\00\00\00\00") - (data $344 (i32.const 16908) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\003\002\00\00\00\00\00") - (data $345 (i32.const 16956) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00I\003\002\00\00\00\00\00") - (data $346 (i32.const 17004) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00L\00O\00A\00D\00_\00I\00N\00D\00_\00U\006\004\00\00\00\00\00") - (data $347 (i32.const 17052) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") - (data $348 (i32.const 17100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $349 (i32.const 17148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00X\00O\00R\00_\00I\00M\00M\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $350 (i32.const 17196) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00M\00M\00") - (data $351 (i32.const 17228) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\003\002\00\00\00\00\00\00\00\00\00") - (data $352 (i32.const 17276) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") - (data $353 (i32.const 17324) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") - (data $354 (i32.const 17372) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $355 (i32.const 17420) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $356 (i32.const 17468) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\003\002\00\00\00") - (data $357 (i32.const 17516) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\003\002\00") - (data $358 (i32.const 17564) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00U\00_\00I\00M\00M\00\00\00\00\00") - (data $359 (i32.const 17612) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00S\00E\00T\00_\00G\00T\00_\00S\00_\00I\00M\00M\00\00\00\00\00") - (data $360 (i32.const 17660) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $361 (i32.const 17724) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $362 (i32.const 17788) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $363 (i32.const 17852) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00I\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") - (data $364 (i32.const 17900) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00C\00M\00O\00V\00_\00N\00Z\00_\00I\00M\00M\00\00\00\00\00\00\00") - (data $365 (i32.const 17948) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") - (data $366 (i32.const 17996) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00M\00U\00L\00_\00I\00M\00M\00_\006\004\00\00\00\00\00\00\00\00\00") - (data $367 (i32.const 18044) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $368 (i32.const 18092) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $369 (i32.const 18140) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\006\004\00\00\00") - (data $370 (i32.const 18188) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1c\00\00\00N\00E\00G\00_\00A\00D\00D\00_\00I\00M\00M\00_\006\004\00") - (data $371 (i32.const 18236) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00L\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $372 (i32.const 18300) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00L\00O\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $373 (i32.const 18364) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00S\00H\00A\00R\00_\00R\00_\00I\00M\00M\00_\00A\00L\00T\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $374 (i32.const 18428) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00\00\00\00\00") - (data $375 (i32.const 18476) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\006\004\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $376 (i32.const 18540) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00\00\00\00\00") - (data $377 (i32.const 18588) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00R\00O\00T\00_\00R\00_\003\002\00_\00I\00M\00M\00_\00A\00L\00T\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $378 (i32.const 18652) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00E\00Q\00\00\00\00\00\00\00\00\00\00\00") - (data $379 (i32.const 18700) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00B\00R\00A\00N\00C\00H\00_\00N\00E\00\00\00\00\00\00\00\00\00\00\00") - (data $380 (i32.const 18748) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00U\00\00\00\00\00\00\00") - (data $381 (i32.const 18796) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00L\00T\00_\00S\00\00\00\00\00\00\00") - (data $382 (i32.const 18844) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00U\00\00\00\00\00\00\00") - (data $383 (i32.const 18892) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00B\00R\00A\00N\00C\00H\00_\00G\00E\00_\00S\00\00\00\00\00\00\00") - (data $384 (i32.const 18940) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00L\00O\00A\00D\00_\00I\00M\00M\00_\00J\00U\00M\00P\00_\00I\00N\00D\00\00\00\00\00\00\00\00\00\00\00") - (data $385 (i32.const 19004) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\003\002\00") - (data $386 (i32.const 19036) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\003\002\00") - (data $387 (i32.const 19068) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\003\002\00") - (data $388 (i32.const 19100) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $389 (i32.const 19148) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $390 (i32.const 19196) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $391 (i32.const 19244) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $392 (i32.const 19292) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $393 (i32.const 19340) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $394 (i32.const 19388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00") - (data $395 (i32.const 19436) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00A\00D\00D\00_\006\004\00") - (data $396 (i32.const 19468) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00S\00U\00B\00_\006\004\00") - (data $397 (i32.const 19500) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00M\00U\00L\00_\006\004\00") - (data $398 (i32.const 19532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $399 (i32.const 19580) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00D\00I\00V\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $400 (i32.const 19628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00U\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $401 (i32.const 19676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00E\00M\00_\00S\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $402 (i32.const 19724) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $403 (i32.const 19772) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00L\00O\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $404 (i32.const 19820) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00S\00H\00A\00R\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00") - (data $405 (i32.const 19868) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00A\00N\00D\00\00\00\00\00\00\00") - (data $406 (i32.const 19900) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00X\00O\00R\00\00\00\00\00\00\00") - (data $407 (i32.const 19932) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00O\00R\00\00\00\00\00\00\00\00\00") - (data $408 (i32.const 19964) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00S\00\00\00") - (data $409 (i32.const 20012) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00U\00_\00U\00\00\00") - (data $410 (i32.const 20060) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00M\00U\00L\00_\00U\00P\00P\00E\00R\00_\00S\00_\00U\00\00\00") - (data $411 (i32.const 20108) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00U\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $412 (i32.const 20156) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00S\00E\00T\00_\00L\00T\00_\00S\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $413 (i32.const 20204) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00I\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $414 (i32.const 20252) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00C\00M\00O\00V\00_\00N\00Z\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $415 (i32.const 20300) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $416 (i32.const 20348) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00L\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $417 (i32.const 20396) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\006\004\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $418 (i32.const 20444) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00R\00O\00T\00_\00R\00_\003\002\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $419 (i32.const 20492) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00A\00N\00D\00_\00I\00N\00V\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $420 (i32.const 20540) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00O\00R\00_\00I\00N\00V\00") - (data $421 (i32.const 20572) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00X\00N\00O\00R\00\00\00\00\00") - (data $422 (i32.const 20604) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00A\00X\00\00\00\00\00\00\00") - (data $423 (i32.const 20636) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00A\00X\00_\00U\00\00\00") - (data $424 (i32.const 20668) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00M\00I\00N\00\00\00\00\00\00\00") - (data $425 (i32.const 20700) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00I\00N\00_\00U\00\00\00") - (data $426 (i32.const 20732) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00s\00h\00o\00u\00l\00d\00 \00p\00a\00r\00s\00e\00 \00p\00a\00c\00k\00e\00d\00 \00m\00a\00s\00k\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00\00\00\00\00\00\00\00\00") - (data $427 (i32.const 20828) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\18\00\00\00\00\00\00\00\00\000@\00\00\00\00\00\00`@\00\00\00\00\00\00o@\00\00\00\00") - (data $428 (i32.const 20876) "l\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00T\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\n\00\00\00\t\00\00\00\08\00\00\00\07\00\00\00\06\00\00\00\05\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $429 (i32.const 20988) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00l\00e\00n\00g\00t\00h\00 \00@\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $430 (i32.const 21036) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b6\00\00\00\00\00\00\00\00\00\00\00") - (data $431 (i32.const 21068) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00X\00\00\00s\00h\00o\00u\00l\00d\00 \00n\00o\00t\00 \00a\00l\00l\00o\00w\00 \00s\00k\00i\00p\00p\00i\00n\00g\00 \00m\00o\00r\00e\00 \00t\00h\00a\00n\00 \002\004\00 \00b\00y\00t\00e\00s\00\00\00\00\00") - (data $432 (i32.const 21180) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00`@\00\00\00\00\00\00\00\00\00\00\00\00") - (data $433 (i32.const 21244) "\9c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\80\00\00\00\00\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\19\00\00\00\18\00\00\00\17\00\00\00\16\00\00\00\15\00\00\00\14\00\00\00\13\00\00\00\12\00\00\00\11\00\00\00\10\00\00\00\0f\00\00\00\0e\00\00\00\r\00\00\00\0c\00\00\00\0b\00\00\00\n\00\00\00\t\00\00\00\08\00\00\00\07\00\00\00\06\00\00\00\05\00\00\00\04\00\00\00\03\00\00\00\02\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $434 (i32.const 21404) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b7\00\00\00\00\00\00\00\00\00\00\00") - (data $435 (i32.const 21436) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00B\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00a\00r\00g\00u\00m\00e\00n\00t\00s\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00\00\00\00\00\00\00\00\00\00\00") - (data $436 (i32.const 21532) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\e0o@\00\00\00\00\00\00\00\00\00\00\00\00") - (data $437 (i32.const 21596) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00^\00\00\00E\00l\00e\00m\00e\00n\00t\00 \00t\00y\00p\00e\00 \00m\00u\00s\00t\00 \00b\00e\00 \00n\00u\00l\00l\00a\00b\00l\00e\00 \00i\00f\00 \00a\00r\00r\00a\00y\00 \00i\00s\00 \00h\00o\00l\00e\00y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $438 (i32.const 21724) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00a\00\00\00\00\00\00\00\00\00\00\00") - (data $439 (i32.const 21756) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00b\00\00\00\00\00\00\00\00\00\00\00") - (data $440 (i32.const 21788) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00c\00\00\00\00\00\00\00\00\00\00\00") - (data $441 (i32.const 21820) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00d\00\00\00\00\00\00\00\00\00\00\00") - (data $442 (i32.const 21852) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b8\00\00\00\00\00\00\00\00\00\00\00") - (data $443 (i32.const 21884) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00L\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00p\00o\00s\00i\00t\00i\00v\00e\00 \00b\00o\00u\00n\00d\00e\00d\00 \00b\00y\00 \00s\00k\00i\00p\00") - (data $444 (i32.const 21980) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\10\00\00\00\00\00\00\00\00\00\14@\00\00\00\00\00\00\14@\00\00\00\00\00\00\00\00\00\00\00\00") - (data $445 (i32.const 22028) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\b9\00\00\00\00\00\00\00\00\00\00\00") - (data $446 (i32.const 22060) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00*\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00b\00l\00o\00b\00 \00p\00r\00o\00g\00r\00a\00m\00\00\00") - (data $447 (i32.const 22124) "\\\01\00\00\00\00\00\00\00\00\00\00\01\00\00\00H\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\80@@\00\00\00\00\00\80I@\00\00\00\00\00\00 @\00\00\00\00\00\00\f0?\00\00\00\00\00\80I@\00\00\00\00\00\00\"@\00\00\00\00\00\00\f0?\00\00\00\00\00\00D@\00\00\00\00\00\00\08@\00\00\00\00\00\00\00\00\00\00\00\00\00\a0b@\00\00\00\00\00\c0]@\00\00\00\00\00\e0o@\00\00\00\00\00@T@\00\00\00\00\00\00\1c@\00\00\00\00\00\00(@\00\00\00\00\00\00Y@\00\00\00\00\00@a@\00\00\00\00\00\00i@\00\00\00\00\00\00c@\00\00\00\00\00\00 @\00\00\00\00\00\00Y@\00\00\00\00\00 e@\00\00\00\00\00\00D@\00\00\00\00\00`n@\00\00\00\00\00\00Y@\00\00\00\00\00\e0`@\00\00\00\00\00\80I@\00\00\00\00\00\00 @\00\00\00\00\00\80I@\00\00\00\00\00\00\"@\00\00\00\00\00\00\f0?\00\00\00\00\00\00I@\00\00\00\00\00\00\00\00\00\00\00\00\00@R@\00\00\00\00\00`b@\00\00\00\00\00\80T@\00\00\00\00\00\a0j@\00\00\00\00\00\00\00\00\00\00\00\00") - (data $448 (i32.const 22476) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00:\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00l\00e\00f\00t\00.\00 \00N\00e\00e\00d\00:\00 \00\00\00") - (data $449 (i32.const 22556) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00l\00e\00f\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $450 (i32.const 22604) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\e0W\00\00\00\00\00\000X\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $451 (i32.const 22652) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\"\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00c\00o\00d\00e\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $452 (i32.const 22716) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00N\00o\00t\00 \00e\00n\00o\00u\00g\00h\00 \00b\00y\00t\00e\00s\00 \00t\00o\00 \00d\00e\00c\00o\00d\00e\00 \00\'\00v\00a\00r\00U\003\002\00\'\00.\00 \00N\00e\00e\00d\00 \00\00\00\00\00\00\00\00\00") - (data $453 (i32.const 22828) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00g\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $454 (i32.const 22876) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\d0X\00\00\00\00\00\00@Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $455 (i32.const 22924) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00M\00a\00s\00k\00[\00\00\00") - (data $456 (i32.const 22956) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00,\00 \00\00\00\00\00\00\00\00\00") - (data $457 (i32.const 22988) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00]\00\00\00\00\00\00\00\00\00\00\00") - (data $458 (i32.const 23020) "\ec\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\d2\00\00\00M\00a\00s\00k\00[\000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \001\00,\00 \000\00,\00 \000\00,\00 \001\00,\00 \00]\00\00\00\00\00\00\00\00\00\00\00") - (data $459 (i32.const 23260) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00\00\00\00\00\00\00\00\00") - (data $460 (i32.const 23308) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00-\00>\00 \00\00\00\00\00") - (data $461 (i32.const 23340) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00 [\00\00\00\00\00\00\c0Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $462 (i32.const 23388) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\16\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00]\00\00\00\00\00\00\00") - (data $463 (i32.const 23436) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\18\00\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\00\00\00\00\00") - (data $464 (i32.const 23484) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\n\00\00\00s\00t\00a\00r\00t\00\00\00") - (data $465 (i32.const 23516) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00e\00n\00d\00\00\00\00\00\00\00") - (data $466 (i32.const 23548) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\00\00\00\00 [\00\00\00\00\00\00\c0Y\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $467 (i32.const 23596) ",\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\01\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \006\00 \00-\00>\00 \00e\00n\00d\00,\00 \008\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \009\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \001\002\00 \00-\00>\00 \00e\00n\00d\00,\00 \001\005\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \002\002\00 \00-\00>\00 \00e\00n\00d\00,\00 \002\004\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \003\000\00 \00-\00>\00 \00e\00n\00d\00,\00 \003\001\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \00]\00\00\00\00\00\00\00\00\00\00\00") - (data $468 (i32.const 23900) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\ba\00\00\00\00\00\00\00\00\00\00\00") - (data $469 (i32.const 23932) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00j\00\00\00s\00h\00o\00u\00l\00d\00 \00c\00o\00n\00s\00t\00r\00u\00c\00t\00 \00b\00a\00s\00i\00c\00 \00b\00l\00o\00c\00k\00s\00 \00c\00o\00r\00r\00e\00c\00t\00l\00y\00 \00b\00a\00s\00e\00d\00 \00o\00n\00 \00s\00k\00i\00p\00\00\00") - (data $470 (i32.const 24060) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00Z\00\00\00O\00p\00c\00o\00d\00e\00 \00n\00o\00t\00 \00f\00o\00u\00n\00d\00 \00i\00n\00 \00R\00U\00N\00 \00t\00a\00b\00l\00e\00 \00f\00o\00r\00 \00i\00n\00s\00t\00r\00u\00c\00t\00i\00o\00n\00\00\00") - (data $471 (i32.const 24172) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\000\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00p\00r\00o\00g\00r\00a\00m\00.\00t\00e\00s\00t\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $472 (i32.const 24252) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00 \00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00`@\00\00\00\00\00\00\00\00\00\00\00\00") - (data $473 (i32.const 24316) "\0c\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\f6\00\00\00M\00a\00s\00k\00[\000\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\005\00,\00 \002\004\00,\00 \002\003\00,\00 \002\002\00,\00 \002\001\00,\00 \002\000\00,\00 \001\009\00,\00 \001\008\00,\00 \001\007\00,\00 \001\006\00,\00 \001\005\00,\00 \001\004\00,\00 \001\003\00,\00 \001\002\00,\00 \001\001\00,\00 \001\000\00,\00 \009\00,\00 \008\00,\00 \007\00,\00 \006\00,\00 \005\00,\00 \004\00,\00 \003\00,\00 \002\00,\00 \001\00,\00 \000\00,\00 \00]\00\00\00\00\00\00\00") - (data $474 (i32.const 24588) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00h\00\00\00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00e\00n\00d\00,\00 \002\006\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \003\001\00 \00-\00>\00 \00e\00n\00d\00,\00 \00]\00\00\00\00\00") - (data $475 (i32.const 24716) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bb\00\00\00\00\00\00\00\00\00\00\00") - (data $476 (i32.const 24748) "l\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00T\00\00\00s\00h\00o\00u\00l\00d\00 \00p\00a\00r\00s\00e\00 \00j\00u\00m\00p\00 \00t\00a\00b\00l\00e\00 \00w\00i\00t\00h\00 \00l\00a\00r\00g\00e\00 \00n\00u\00m\00b\00e\00r\00s\00\00\00\00\00\00\00\00\00") - (data $477 (i32.const 24860) "\0c\01\00\00\00\00\00\00\00\00\00\00\01\00\00\00\f0\00\00\00\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\f0?\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00@\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $478 (i32.const 25132) "\cc\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\b8\00\00\00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\000\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \001\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \002\00 \00-\00>\00 \001\008\004\004\006\007\004\004\000\007\003\007\000\009\005\005\001\006\001\005\00,\00 \00]\00\00\00\00\00") - (data $479 (i32.const 25340) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bc\00\00\00\00\00\00\00\00\00\00\00") - (data $480 (i32.const 25372) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00<\00\00\00s\00h\00o\00u\00l\00d\00 \00d\00e\00c\00o\00d\00e\00 \00s\00t\00a\00n\00d\00a\00r\00d\00 \00p\00r\00o\00g\00r\00a\00m\00") - (data $481 (i32.const 25452) ",\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\1c\00\00\00\04\00\00\02\00\00\03\00 \00\00\ab\cd\ef\01\124\07\00\00\00\00\00\03\c8\87\t\01") - (data $482 (i32.const 25500) "\1c\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\03\00\00\00\124V\00\00\00\00\00\00\00\00\00") - (data $483 (i32.const 25532) "\\\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00D\00\00\00A\00r\00g\00u\00m\00e\00n\00t\00s\00 \00l\00e\00n\00g\00t\00h\00 \00i\00s\00 \00t\00o\00o\00 \00b\00i\00g\00.\00 \00G\00o\00t\00:\00 \00\00\00\00\00\00\00\00\00") - (data $484 (i32.const 25628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00,\00 \00m\00a\00x\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $485 (i32.const 25676) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\10\00\00\00\d0c\00\00\00\00\00\000d\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $486 (i32.const 25724) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00s\00p\00i\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $487 (i32.const 25788) "|\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00f\00\00\00E\00x\00p\00e\00c\00t\00i\00n\00g\00 \00t\00o\00 \00u\00s\00e\00 \00a\00l\00l\00 \00b\00y\00t\00e\00s\00 \00f\00r\00o\00m\00 \00t\00h\00e\00 \00d\00e\00c\00o\00d\00e\00r\00.\00 \00L\00e\00f\00t\00:\00 \00\00\00\00\00\00\00") - (data $488 (i32.const 25916) "L\00\00\00\00\00\00\00\00\00\00\00\02\00\00\006\00\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00\00\00\00\00\00\00") - (data $489 (i32.const 25996) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $490 (i32.const 26060) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \00\00\00") - (data $491 (i32.const 26108) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00}\00\00\00\00\00\00\00\00\00") - (data $492 (i32.const 26140) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00Pe\00\00\00\00\00\00\a0e\00\00\00\00\00\00\e0e\00\00\00\00\00\00\10f\00\00") - (data $493 (i32.const 26188) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00 \00\00\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $494 (i32.const 26252) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00,\00 \00m\00a\00s\00k\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $495 (i32.const 26300) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1a\00\00\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00\00\00") - (data $496 (i32.const 26348) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\1e\00\00\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $497 (i32.const 26412) "<\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00$\00\00\00`f\00\00\00\00\00\00\a0f\00\00\00\00\00\00\d0f\00\00\00\00\00\00\00g\00\00\00\00\00\00\10f\00\00\00\00\00\00\00\00\00\00") - (data $498 (i32.const 26476) "\dc\01\00\00\00\00\00\00\00\00\00\00\02\00\00\00\c2\01\00\00S\00t\00a\00n\00d\00a\00r\00d\00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00p\00r\00o\00g\00r\00a\00m\00:\00 \00P\00r\00o\00g\00r\00a\00m\00 \00{\00 \00c\00o\00d\00e\00:\00 \002\000\000\00,\001\003\005\00,\009\00,\00 \00m\00a\00s\00k\00:\00 \00M\00a\00s\00k\00[\000\00,\00 \002\00,\00 \001\00,\00 \00]\00,\00 \00j\00u\00m\00p\00T\00a\00b\00l\00e\00:\00 \00J\00u\00m\00p\00T\00a\00b\00l\00e\00[\00]\00,\00 \00b\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00:\00 \00B\00a\00s\00i\00c\00B\00l\00o\00c\00k\00s\00[\000\00 \00-\00>\00 \00s\00t\00a\00r\00t\00,\00 \00]\00 \00}\00,\00 \00m\00e\00m\00o\00r\00y\00_\00p\00a\00g\00e\00s\00:\00 \007\00,\00 \00r\00e\00g\00i\00s\00t\00e\00r\00s\00:\00 \004\002\009\004\009\000\001\007\006\000\00,\004\002\007\008\000\005\009\000\000\008\00,\000\00,\000\00,\000\00,\000\00,\000\00,\004\002\007\008\001\002\004\005\004\004\00,\003\00,\000\00,\000\00,\000\00,\000\00 \00}\00\00\00\00\00\00\00\00\00\00\00") - (data $499 (i32.const 26956) "\1c\00\00\00\00\00\00\00\00\00\00\00\1a\00\00\00\08\00\00\00\bd\00\00\00\00\00\00\00\00\00\00\00") - (data $500 (i32.const 26988) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00b\00i\00t\00.\00t\00s\00") - (data $501 (i32.const 27020) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00>\00 \00\00\00\00\00\00\00\00\00") - (data $502 (i32.const 27052) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00>\00>\00>\00 \00") - (data $503 (i32.const 27084) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00 \00 \00<\00<\00<\00 \00") - (data $504 (i32.const 27116) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00 \00\05\'\00\00\00\00\00\00\00\00") - (data $505 (i32.const 27148) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00\e0i\00\00\00\00\00\00\00j\00\00") - (data $506 (i32.const 27180) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\08\00\00\00 \00 \00 \00 \00\00\00\00\00") - (data $507 (i32.const 27212) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00=\d84\dd\00\00\00\00\00\00") - (data $508 (i32.const 27244) "\1c\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\0c\00\00\00\e0i\00\00\00\00\00\00`j\00\00") - (data $509 (i32.const 27276) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00<\00 \00\00\00\00\00\00\00\00\00") - (data $510 (i32.const 27308) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00\05\'\00\00\00\00\00\00\00\00\00\00") - (data $511 (i32.const 27340) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\04\00\00\00=\d84\dd\00\00\00\00\00\00\00\00") - (data $512 (i32.const 27372) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\02\00\00\00 \00\00\00\00\00\00\00\00\00\00\00") - (data $513 (i32.const 27404) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\06\00\00\00 \00/\00 \00\00\00\00\00\00\00") - (data $514 (i32.const 27436) ",\00\00\00\03\00\00\00\00\00\00\00\19\00\00\00\1c\00\00\00\00\00\00\00\00k\00\00\00\00\00\00 k\00\00\00\00\00\00\00k\00\00\00\00\00\00") - (data $515 (i32.const 27484) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00b\00r\00a\00n\00c\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $516 (i32.const 27532) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\10\00\00\00l\00o\00g\00i\00c\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $517 (i32.const 27580) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00m\00a\00t\00h\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $518 (i32.const 27628) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\12\00\00\00m\00e\00m\00o\00r\00y\00.\00t\00s\00\00\00\00\00\00\00\00\00\00\00") - (data $519 (i32.const 27676) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\14\00\00\00p\00r\00o\00g\00r\00a\00m\00.\00t\00s\00\00\00\00\00\00\00\00\00") - (data $520 (i32.const 27724) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00r\00o\00t\00.\00t\00s\00") - (data $521 (i32.const 27756) "\1c\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0c\00\00\00s\00p\00i\00.\00t\00s\00") - (data $522 (i32.const 27788) ",\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00\0e\00\00\00\n\00\n\00T\00o\00t\00a\00l\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00") - (data $523 (i32.const 27836) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00$\00\00\00S\00o\00m\00e\00 \00t\00e\00s\00t\00s\00 \00f\00a\00i\00l\00e\00d\00.\00\00\00\00\00\00\00\00\00") - (data $524 (i32.const 27900) "<\00\00\00\00\00\00\00\00\00\00\00\02\00\00\00(\00\00\00a\00s\00s\00e\00m\00b\00l\00y\00/\00t\00e\00s\00t\00-\00r\00u\00n\00.\00t\00s\00\00\00\00\00") - (data $525 (i32.const 27968) "0\00\00\00 \00\00\00 \00\00\00 \00\00\00\00\00\00\00\02\t\00\00A\00\00\00 \00\00\00\02A\00\00\00\00\00\00 \00\00\00 \00\00\00\00\00\00\00\00\00\00\00$\02\00\00\00\00\00\00\00\00\00\00\02A\00\00\10A\02\00 \00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\02A\00\00\02A\00\00\00\00\00\00\04A\00\00\00\00\00\00\00\00\00\00\00\00\00\00d\00\00\00\00\00\00\00\00\00\00\00A\00\00\00\02A\00\00B\00\00\00\00\00\00\00\02\01\00\00\00\00\00\00$\01\00\00\02\1a\00\00\02\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00$\t\00\00\00\00\00\00 \00\00\00\00\00\00\00") - (table $0 190 190 funcref) - (elem $0 (i32.const 1) $start:assembly/arguments~anonymous|0 $start:assembly/arguments~anonymous|1 $start:assembly/arguments~anonymous|2 $start:assembly/arguments~anonymous|3 $start:assembly/arguments~anonymous|4 $start:assembly/arguments~anonymous|5 $start:assembly/arguments~anonymous|6 $start:assembly/arguments~anonymous|7 $start:assembly/arguments~anonymous|8 $start:assembly/arguments~anonymous|9 $start:assembly/arguments~anonymous|10 $start:assembly/arguments~anonymous|11 $start:assembly/arguments~anonymous|12 $start:assembly/instructions/bit~anonymous|0 $start:assembly/instructions/bit~anonymous|1 $start:assembly/instructions/bit~anonymous|2 $start:assembly/instructions/bit~anonymous|3 $start:assembly/instructions/bit~anonymous|4 $start:assembly/instructions/bit~anonymous|5 $start:assembly/instructions/bit~anonymous|6 $start:assembly/instructions/bit~anonymous|7 $start:assembly/instructions/bit~anonymous|8 $start:assembly/instructions/bit~anonymous|9 $start:assembly/instructions/bit.test~anonymous|0 $start:assembly/instructions/bit.test~anonymous|1 $start:assembly/instructions/bit.test~anonymous|2 $start:assembly/instructions/bit.test~anonymous|3 $start:assembly/instructions/bit.test~anonymous|4 $start:assembly/instructions/bit.test~anonymous|5 $start:assembly/instructions/bit.test~anonymous|6 $start:assembly/instructions/bit.test~anonymous|7 $start:assembly/instructions/bit.test~anonymous|8 $start:assembly/instructions/bit.test~anonymous|9 $start:assembly/instructions/branch~anonymous|0 $start:assembly/instructions/branch~anonymous|1 $start:assembly/instructions/branch~anonymous|2 $start:assembly/instructions/branch~anonymous|3 $start:assembly/instructions/branch~anonymous|4 $start:assembly/instructions/branch~anonymous|5 $start:assembly/instructions/branch~anonymous|6 $start:assembly/instructions/branch~anonymous|7 $start:assembly/instructions/branch~anonymous|8 $start:assembly/instructions/branch~anonymous|9 $start:assembly/instructions/branch~anonymous|10 $start:assembly/instructions/branch~anonymous|11 $start:assembly/instructions/branch~anonymous|12 $start:assembly/instructions/branch~anonymous|13 $start:assembly/instructions/branch~anonymous|14 $start:assembly/instructions/branch~anonymous|15 $start:assembly/instructions/branch.test~anonymous|0 $start:assembly/instructions/logic~anonymous|0 $start:assembly/instructions/logic~anonymous|1 $start:assembly/instructions/logic~anonymous|2 $start:assembly/instructions/logic~anonymous|3 $start:assembly/instructions/logic~anonymous|4 $start:assembly/instructions/logic~anonymous|5 $start:assembly/instructions/logic~anonymous|6 $start:assembly/instructions/logic~anonymous|7 $start:assembly/instructions/logic~anonymous|8 $start:assembly/instructions/logic.test~anonymous|0 $start:assembly/instructions/logic.test~anonymous|1 $start:assembly/instructions/logic.test~anonymous|2 $start:assembly/instructions/math~anonymous|0 $start:assembly/instructions/math~anonymous|1 $start:assembly/instructions/math~anonymous|2 $start:assembly/instructions/math~anonymous|3 $start:assembly/instructions/math~anonymous|4 $start:assembly/instructions/math~anonymous|5 $start:assembly/instructions/math~anonymous|6 $start:assembly/instructions/math~anonymous|7 $start:assembly/instructions/math~anonymous|8 $start:assembly/instructions/math~anonymous|9 $start:assembly/instructions/math~anonymous|10 $start:assembly/instructions/math~anonymous|11 $start:assembly/instructions/math~anonymous|12 $start:assembly/instructions/math~anonymous|13 $start:assembly/instructions/math~anonymous|14 $start:assembly/instructions/math~anonymous|15 $start:assembly/instructions/math~anonymous|16 $start:assembly/instructions/math~anonymous|17 $start:assembly/instructions/math~anonymous|18 $start:assembly/instructions/math~anonymous|19 $start:assembly/instructions/math~anonymous|20 $start:assembly/instructions/math~anonymous|21 $start:assembly/instructions/math~anonymous|22 $start:assembly/instructions/math~anonymous|23 $start:assembly/instructions/math~anonymous|24 $start:assembly/instructions/math~anonymous|25 $start:assembly/instructions/math~anonymous|26 $start:assembly/instructions/math.test~anonymous|0 $start:assembly/instructions/math.test~anonymous|1 $start:assembly/instructions/math.test~anonymous|2 $start:assembly/instructions/math.test~anonymous|3 $start:assembly/instructions/math.test~anonymous|4 $start:assembly/instructions/rot~anonymous|0 $start:assembly/instructions/rot~anonymous|1 $start:assembly/instructions/rot~anonymous|2 $start:assembly/instructions/rot~anonymous|3 $start:assembly/instructions/rot~anonymous|4 $start:assembly/instructions/rot~anonymous|5 $start:assembly/instructions/rot~anonymous|6 $start:assembly/instructions/rot~anonymous|7 $start:assembly/instructions/rot.test~anonymous|0 $start:assembly/instructions/rot.test~anonymous|1 $start:assembly/instructions/rot.test~anonymous|2 $start:assembly/instructions/rot.test~anonymous|3 $start:assembly/memory.test~anonymous|0 $start:assembly/memory.test~anonymous|1 $start:assembly/memory.test~anonymous|2 $start:assembly/memory.test~anonymous|3 $start:assembly/instructions/jump~anonymous|0 $start:assembly/instructions/jump~anonymous|1 $start:assembly/instructions/jump~anonymous|2 $start:assembly/instructions/jump~anonymous|3 $start:assembly/instructions/misc~anonymous|0 $start:assembly/instructions/misc~anonymous|1 $start:assembly/instructions/misc~anonymous|2 $start:assembly/instructions/misc~anonymous|3 $start:assembly/instructions/misc~anonymous|4 $start:assembly/instructions/load~anonymous|0 $start:assembly/instructions/load~anonymous|1 $start:assembly/instructions/load~anonymous|2 $start:assembly/instructions/load~anonymous|3 $start:assembly/instructions/load~anonymous|4 $start:assembly/instructions/load~anonymous|5 $start:assembly/instructions/load~anonymous|6 $start:assembly/instructions/load~anonymous|7 $start:assembly/instructions/load~anonymous|8 $start:assembly/instructions/load~anonymous|9 $start:assembly/instructions/load~anonymous|10 $start:assembly/instructions/load~anonymous|11 $start:assembly/instructions/load~anonymous|12 $start:assembly/instructions/load~anonymous|13 $start:assembly/instructions/load~anonymous|14 $start:assembly/instructions/load~anonymous|15 $start:assembly/instructions/mov~anonymous|0 $start:assembly/instructions/mov~anonymous|1 $start:assembly/instructions/mov~anonymous|2 $start:assembly/instructions/mov~anonymous|3 $start:assembly/instructions/mov~anonymous|4 $start:assembly/instructions/set~anonymous|0 $start:assembly/instructions/set~anonymous|1 $start:assembly/instructions/set~anonymous|2 $start:assembly/instructions/set~anonymous|3 $start:assembly/instructions/set~anonymous|4 $start:assembly/instructions/set~anonymous|5 $start:assembly/instructions/shift~anonymous|0 $start:assembly/instructions/shift~anonymous|1 $start:assembly/instructions/shift~anonymous|2 $start:assembly/instructions/shift~anonymous|3 $start:assembly/instructions/shift~anonymous|4 $start:assembly/instructions/shift~anonymous|5 $start:assembly/instructions/shift~anonymous|6 $start:assembly/instructions/shift~anonymous|7 $start:assembly/instructions/shift~anonymous|8 $start:assembly/instructions/shift~anonymous|9 $start:assembly/instructions/shift~anonymous|10 $start:assembly/instructions/shift~anonymous|11 $start:assembly/instructions/shift~anonymous|12 $start:assembly/instructions/shift~anonymous|13 $start:assembly/instructions/shift~anonymous|14 $start:assembly/instructions/shift~anonymous|15 $start:assembly/instructions/shift~anonymous|16 $start:assembly/instructions/shift~anonymous|17 $start:assembly/instructions/store~anonymous|0 $start:assembly/instructions/store~anonymous|1 $start:assembly/instructions/store~anonymous|2 $start:assembly/instructions/store~anonymous|3 $start:assembly/instructions/store~anonymous|4 $start:assembly/instructions/store~anonymous|5 $start:assembly/instructions/store~anonymous|6 $start:assembly/instructions/store~anonymous|7 $start:assembly/instructions/store~anonymous|8 $start:assembly/instructions/store~anonymous|9 $start:assembly/instructions/store~anonymous|10 $start:assembly/instructions/store~anonymous|11 $start:assembly/instructions/store~anonymous|12 $start:assembly/instructions/store~anonymous|13 $start:assembly/instructions/store~anonymous|14 $start:assembly/instructions/store~anonymous|15 $start:assembly/codec~anonymous|0 $start:assembly/program.test~anonymous|0 $start:assembly/program.test~anonymous|1 $start:assembly/program.test~anonymous|2 $start:assembly/program.test~anonymous|3 $start:assembly/program.test~anonymous|4 $start:assembly/program.test~anonymous|5 $start:assembly/program.test~anonymous|6 $start:assembly/spi.test~anonymous|0) - (export "runAllTests" (func $assembly/test-run/runAllTests)) - (export "memory" (memory $0)) - (start $~start) - (func $~lib/rt/itcms/Object#set:nextWithColor (param $this i32) (param $nextWithColor i32) - local.get $this - local.get $nextWithColor - i32.store offset=4 - ) - (func $~lib/rt/itcms/Object#set:prev (param $this i32) (param $prev i32) - local.get $this - local.get $prev - i32.store offset=8 - ) - (func $~lib/rt/itcms/initLazy (param $space i32) (result i32) - local.get $space - local.get $space - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $space - local.get $space - call $~lib/rt/itcms/Object#set:prev - local.get $space - return - ) - (func $~lib/rt/itcms/Object#get:nextWithColor (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/rt/itcms/Object#get:next (param $this i32) (result i32) - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.const -1 - i32.xor - i32.and - return - ) - (func $~lib/rt/itcms/Object#get:color (param $this i32) (result i32) - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.and - return - ) - (func $~lib/rt/itcms/visitRoots (param $cookie i32) - (local $pn i32) - (local $iter i32) - local.get $cookie - call $~lib/rt/__visit_globals - global.get $~lib/rt/itcms/pinSpace - local.set $pn - local.get $pn - call $~lib/rt/itcms/Object#get:next - local.set $iter - loop $while-continue|0 - local.get $iter - local.get $pn - i32.ne - if - i32.const 1 - drop - local.get $iter - call $~lib/rt/itcms/Object#get:color - i32.const 3 - i32.eq - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 160 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $iter - i32.const 20 - i32.add - local.get $cookie - call $~lib/rt/__visit_members - local.get $iter - call $~lib/rt/itcms/Object#get:next - local.set $iter - br $while-continue|0 - end - end - ) - (func $~lib/rt/itcms/Object#set:color (param $this i32) (param $color i32) - local.get $this - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $color - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - ) - (func $~lib/rt/itcms/Object#get:prev (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/rt/itcms/Object#set:next (param $this i32) (param $obj i32) - local.get $this - local.get $obj - local.get $this - call $~lib/rt/itcms/Object#get:nextWithColor - i32.const 3 - i32.and - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - ) - (func $~lib/rt/itcms/Object#unlink (param $this i32) - (local $next i32) - (local $prev i32) - local.get $this - call $~lib/rt/itcms/Object#get:next - local.set $next - local.get $next - i32.const 0 - i32.eq - if - i32.const 1 - drop - local.get $this - call $~lib/rt/itcms/Object#get:prev - i32.const 0 - i32.eq - if (result i32) - local.get $this - global.get $~lib/memory/__heap_base - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 128 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - return - end - local.get $this - call $~lib/rt/itcms/Object#get:prev - local.set $prev - i32.const 1 - drop - local.get $prev - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 132 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $next - local.get $prev - call $~lib/rt/itcms/Object#set:prev - local.get $prev - local.get $next - call $~lib/rt/itcms/Object#set:next - ) - (func $~lib/rt/itcms/Object#get:rtId (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/shared/typeinfo/Typeinfo#get:flags (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/__typeinfo (param $id i32) (result i32) - (local $ptr i32) - global.get $~lib/rt/__rtti_base - local.set $ptr - local.get $id - local.get $ptr - i32.load - i32.gt_u - if - i32.const 480 - i32.const 544 - i32.const 21 - i32.const 28 - call $~lib/builtins/abort - unreachable - end - local.get $ptr - i32.const 4 - i32.add - local.get $id - i32.const 4 - i32.mul - i32.add - call $~lib/shared/typeinfo/Typeinfo#get:flags - return - ) - (func $~lib/rt/itcms/Object#get:isPointerfree (param $this i32) (result i32) - (local $rtId i32) - local.get $this - call $~lib/rt/itcms/Object#get:rtId - local.set $rtId - local.get $rtId - i32.const 2 - i32.le_u - if (result i32) - i32.const 1 - else - local.get $rtId - call $~lib/rt/__typeinfo - i32.const 32 - i32.and - i32.const 0 - i32.ne - end - return - ) - (func $~lib/rt/itcms/Object#linkTo (param $this i32) (param $list i32) (param $withColor i32) - (local $prev i32) - local.get $list - call $~lib/rt/itcms/Object#get:prev - local.set $prev - local.get $this - local.get $list - local.get $withColor - i32.or - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $this - local.get $prev - call $~lib/rt/itcms/Object#set:prev - local.get $prev - local.get $this - call $~lib/rt/itcms/Object#set:next - local.get $list - local.get $this - call $~lib/rt/itcms/Object#set:prev - ) - (func $~lib/rt/itcms/Object#makeGray (param $this i32) - (local $1 i32) - local.get $this - global.get $~lib/rt/itcms/iter - i32.eq - if - local.get $this - call $~lib/rt/itcms/Object#get:prev - local.tee $1 - i32.eqz - if (result i32) - i32.const 0 - i32.const 352 - i32.const 148 - i32.const 30 - call $~lib/builtins/abort - unreachable - else - local.get $1 - end - global.set $~lib/rt/itcms/iter - end - local.get $this - call $~lib/rt/itcms/Object#unlink - local.get $this - global.get $~lib/rt/itcms/toSpace - local.get $this - call $~lib/rt/itcms/Object#get:isPointerfree - if (result i32) - global.get $~lib/rt/itcms/white - i32.eqz - else - i32.const 2 - end - call $~lib/rt/itcms/Object#linkTo - ) - (func $~lib/rt/itcms/__visit (param $ptr i32) (param $cookie i32) - (local $obj i32) - local.get $ptr - i32.eqz - if - return - end - local.get $ptr - i32.const 20 - i32.sub - local.set $obj - i32.const 0 - drop - local.get $obj - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eq - if - local.get $obj - call $~lib/rt/itcms/Object#makeGray - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.add - global.set $~lib/rt/itcms/visitCount - end - ) - (func $~lib/rt/itcms/visitStack (param $cookie i32) - (local $ptr i32) - global.get $~lib/memory/__stack_pointer - local.set $ptr - loop $while-continue|0 - local.get $ptr - global.get $~lib/memory/__heap_base - i32.lt_u - if - local.get $ptr - i32.load - local.get $cookie - call $~lib/rt/itcms/__visit - local.get $ptr - i32.const 4 - i32.add - local.set $ptr - br $while-continue|0 - end - end - ) - (func $~lib/rt/common/BLOCK#get:mmInfo (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/itcms/Object#get:size (param $this i32) (result i32) - i32.const 4 - local.get $this - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - return - ) - (func $~lib/rt/tlsf/Root#set:flMap (param $this i32) (param $flMap i32) - local.get $this - local.get $flMap - i32.store - ) - (func $~lib/rt/common/BLOCK#set:mmInfo (param $this i32) (param $mmInfo i32) - local.get $this - local.get $mmInfo - i32.store - ) - (func $~lib/rt/tlsf/Block#set:prev (param $this i32) (param $prev i32) - local.get $this - local.get $prev - i32.store offset=4 - ) - (func $~lib/rt/tlsf/Block#set:next (param $this i32) (param $next i32) - local.get $this - local.get $next - i32.store offset=8 - ) - (func $~lib/rt/tlsf/Block#get:prev (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/rt/tlsf/Block#get:next (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/rt/tlsf/Root#get:flMap (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/tlsf/removeBlock (param $root i32) (param $block i32) - (local $blockInfo i32) - (local $size i32) - (local $fl i32) - (local $sl i32) - (local $6 i32) - (local $7 i32) - (local $boundedSize i32) - (local $prev i32) - (local $next i32) - (local $root|11 i32) - (local $fl|12 i32) - (local $sl|13 i32) - (local $root|14 i32) - (local $fl|15 i32) - (local $sl|16 i32) - (local $head i32) - (local $root|18 i32) - (local $fl|19 i32) - (local $slMap i32) - (local $root|21 i32) - (local $fl|22 i32) - (local $slMap|23 i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $blockInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 268 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.set $size - i32.const 1 - drop - local.get $size - i32.const 12 - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 270 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - local.tee $6 - i32.const 1073741820 - local.tee $7 - local.get $6 - local.get $7 - i32.lt_u - select - local.set $boundedSize - i32.const 31 - local.get $boundedSize - i32.clz - i32.sub - local.set $fl - local.get $boundedSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 284 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $block - call $~lib/rt/tlsf/Block#get:prev - local.set $prev - local.get $block - call $~lib/rt/tlsf/Block#get:next - local.set $next - local.get $prev - if - local.get $prev - local.get $next - call $~lib/rt/tlsf/Block#set:next - end - local.get $next - if - local.get $next - local.get $prev - call $~lib/rt/tlsf/Block#set:prev - end - local.get $block - block $~lib/rt/tlsf/GETHEAD|inlined.0 (result i32) - local.get $root - local.set $root|11 - local.get $fl - local.set $fl|12 - local.get $sl - local.set $sl|13 - local.get $root|11 - local.get $fl|12 - i32.const 4 - i32.shl - local.get $sl|13 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.0 - end - i32.eq - if - local.get $root - local.set $root|14 - local.get $fl - local.set $fl|15 - local.get $sl - local.set $sl|16 - local.get $next - local.set $head - local.get $root|14 - local.get $fl|15 - i32.const 4 - i32.shl - local.get $sl|16 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head - i32.store offset=96 - local.get $next - i32.eqz - if - block $~lib/rt/tlsf/GETSL|inlined.0 (result i32) - local.get $root - local.set $root|18 - local.get $fl - local.set $fl|19 - local.get $root|18 - local.get $fl|19 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.0 - end - local.set $slMap - local.get $root - local.set $root|21 - local.get $fl - local.set $fl|22 - local.get $slMap - i32.const 1 - local.get $sl - i32.shl - i32.const -1 - i32.xor - i32.and - local.tee $slMap - local.set $slMap|23 - local.get $root|21 - local.get $fl|22 - i32.const 2 - i32.shl - i32.add - local.get $slMap|23 - i32.store offset=4 - local.get $slMap - i32.eqz - if - local.get $root - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 1 - local.get $fl - i32.shl - i32.const -1 - i32.xor - i32.and - call $~lib/rt/tlsf/Root#set:flMap - end - end - end - ) - (func $~lib/rt/tlsf/insertBlock (param $root i32) (param $block i32) - (local $blockInfo i32) - (local $block|3 i32) - (local $right i32) - (local $rightInfo i32) - (local $block|6 i32) - (local $block|7 i32) - (local $left i32) - (local $leftInfo i32) - (local $size i32) - (local $fl i32) - (local $sl i32) - (local $13 i32) - (local $14 i32) - (local $boundedSize i32) - (local $root|16 i32) - (local $fl|17 i32) - (local $sl|18 i32) - (local $head i32) - (local $root|20 i32) - (local $fl|21 i32) - (local $sl|22 i32) - (local $head|23 i32) - (local $root|24 i32) - (local $fl|25 i32) - (local $root|26 i32) - (local $fl|27 i32) - (local $slMap i32) - i32.const 1 - drop - local.get $block - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 201 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $blockInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 203 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETRIGHT|inlined.0 (result i32) - local.get $block - local.set $block|3 - local.get $block|3 - i32.const 4 - i32.add - local.get $block|3 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.0 - end - local.set $right - local.get $right - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $rightInfo - local.get $rightInfo - i32.const 1 - i32.and - if - local.get $root - local.get $right - call $~lib/rt/tlsf/removeBlock - local.get $block - local.get $blockInfo - i32.const 4 - i32.add - local.get $rightInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - local.tee $blockInfo - call $~lib/rt/common/BLOCK#set:mmInfo - block $~lib/rt/tlsf/GETRIGHT|inlined.1 (result i32) - local.get $block - local.set $block|6 - local.get $block|6 - i32.const 4 - i32.add - local.get $block|6 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.1 - end - local.set $right - local.get $right - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $rightInfo - end - local.get $blockInfo - i32.const 2 - i32.and - if - block $~lib/rt/tlsf/GETFREELEFT|inlined.0 (result i32) - local.get $block - local.set $block|7 - local.get $block|7 - i32.const 4 - i32.sub - i32.load - br $~lib/rt/tlsf/GETFREELEFT|inlined.0 - end - local.set $left - local.get $left - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $leftInfo - i32.const 1 - drop - local.get $leftInfo - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 221 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $root - local.get $left - call $~lib/rt/tlsf/removeBlock - local.get $left - local.set $block - local.get $block - local.get $leftInfo - i32.const 4 - i32.add - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - local.tee $blockInfo - call $~lib/rt/common/BLOCK#set:mmInfo - end - local.get $right - local.get $rightInfo - i32.const 2 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.set $size - i32.const 1 - drop - local.get $size - i32.const 12 - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 233 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - i32.const 1 - drop - local.get $block - i32.const 4 - i32.add - local.get $size - i32.add - local.get $right - i32.eq - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 234 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $right - i32.const 4 - i32.sub - local.get $block - i32.store - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - local.tee $13 - i32.const 1073741820 - local.tee $14 - local.get $13 - local.get $14 - i32.lt_u - select - local.set $boundedSize - i32.const 31 - local.get $boundedSize - i32.clz - i32.sub - local.set $fl - local.get $boundedSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 251 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETHEAD|inlined.1 (result i32) - local.get $root - local.set $root|16 - local.get $fl - local.set $fl|17 - local.get $sl - local.set $sl|18 - local.get $root|16 - local.get $fl|17 - i32.const 4 - i32.shl - local.get $sl|18 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.1 - end - local.set $head - local.get $block - i32.const 0 - call $~lib/rt/tlsf/Block#set:prev - local.get $block - local.get $head - call $~lib/rt/tlsf/Block#set:next - local.get $head - if - local.get $head - local.get $block - call $~lib/rt/tlsf/Block#set:prev - end - local.get $root - local.set $root|20 - local.get $fl - local.set $fl|21 - local.get $sl - local.set $sl|22 - local.get $block - local.set $head|23 - local.get $root|20 - local.get $fl|21 - i32.const 4 - i32.shl - local.get $sl|22 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head|23 - i32.store offset=96 - local.get $root - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 1 - local.get $fl - i32.shl - i32.or - call $~lib/rt/tlsf/Root#set:flMap - local.get $root - local.set $root|26 - local.get $fl - local.set $fl|27 - block $~lib/rt/tlsf/GETSL|inlined.1 (result i32) - local.get $root - local.set $root|24 - local.get $fl - local.set $fl|25 - local.get $root|24 - local.get $fl|25 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.1 - end - i32.const 1 - local.get $sl - i32.shl - i32.or - local.set $slMap - local.get $root|26 - local.get $fl|27 - i32.const 2 - i32.shl - i32.add - local.get $slMap - i32.store offset=4 - ) - (func $~lib/rt/tlsf/addMemory (param $root i32) (param $start i32) (param $endU64 i64) (result i32) - (local $end i32) - (local $root|4 i32) - (local $tail i32) - (local $tailInfo i32) - (local $size i32) - (local $leftSize i32) - (local $left i32) - (local $root|10 i32) - (local $tail|11 i32) - local.get $endU64 - i32.wrap_i64 - local.set $end - i32.const 1 - drop - local.get $start - i64.extend_i32_u - local.get $endU64 - i64.le_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 382 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $start - i32.const 4 - i32.add - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - i32.const 4 - i32.sub - local.set $start - local.get $end - i32.const 15 - i32.const -1 - i32.xor - i32.and - local.set $end - block $~lib/rt/tlsf/GETTAIL|inlined.0 (result i32) - local.get $root - local.set $root|4 - local.get $root|4 - i32.load offset=1568 - br $~lib/rt/tlsf/GETTAIL|inlined.0 - end - local.set $tail - i32.const 0 - local.set $tailInfo - local.get $tail - if - i32.const 1 - drop - local.get $start - local.get $tail - i32.const 4 - i32.add - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 389 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - local.get $start - i32.const 16 - i32.sub - local.get $tail - i32.eq - if - local.get $start - i32.const 16 - i32.sub - local.set $start - local.get $tail - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $tailInfo - else - end - else - i32.const 1 - drop - local.get $start - local.get $root - i32.const 1572 - i32.add - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 402 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - end - local.get $end - local.get $start - i32.sub - local.set $size - local.get $size - i32.const 4 - i32.const 12 - i32.add - i32.const 4 - i32.add - i32.lt_u - if - i32.const 0 - return - end - local.get $size - i32.const 2 - i32.const 4 - i32.mul - i32.sub - local.set $leftSize - local.get $start - local.set $left - local.get $left - local.get $leftSize - i32.const 1 - i32.or - local.get $tailInfo - i32.const 2 - i32.and - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $left - i32.const 0 - call $~lib/rt/tlsf/Block#set:prev - local.get $left - i32.const 0 - call $~lib/rt/tlsf/Block#set:next - local.get $start - i32.const 4 - i32.add - local.get $leftSize - i32.add - local.set $tail - local.get $tail - i32.const 0 - i32.const 2 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.set $root|10 - local.get $tail - local.set $tail|11 - local.get $root|10 - local.get $tail|11 - i32.store offset=1568 - local.get $root - local.get $left - call $~lib/rt/tlsf/insertBlock - i32.const 1 - return - ) - (func $~lib/rt/tlsf/initialize - (local $rootOffset i32) - (local $pagesBefore i32) - (local $pagesNeeded i32) - (local $root i32) - (local $root|4 i32) - (local $tail i32) - (local $fl i32) - (local $root|7 i32) - (local $fl|8 i32) - (local $slMap i32) - (local $sl i32) - (local $root|11 i32) - (local $fl|12 i32) - (local $sl|13 i32) - (local $head i32) - (local $memStart i32) - i32.const 0 - drop - global.get $~lib/memory/__heap_base - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - local.set $rootOffset - memory.size - local.set $pagesBefore - local.get $rootOffset - i32.const 1572 - i32.add - i32.const 65535 - i32.add - i32.const 65535 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.shr_u - local.set $pagesNeeded - local.get $pagesNeeded - local.get $pagesBefore - i32.gt_s - if (result i32) - local.get $pagesNeeded - local.get $pagesBefore - i32.sub - memory.grow - i32.const 0 - i32.lt_s - else - i32.const 0 - end - if - unreachable - end - local.get $rootOffset - local.set $root - local.get $root - i32.const 0 - call $~lib/rt/tlsf/Root#set:flMap - local.get $root - local.set $root|4 - i32.const 0 - local.set $tail - local.get $root|4 - local.get $tail - i32.store offset=1568 - i32.const 0 - local.set $fl - loop $for-loop|0 - local.get $fl - i32.const 23 - i32.lt_u - if - local.get $root - local.set $root|7 - local.get $fl - local.set $fl|8 - i32.const 0 - local.set $slMap - local.get $root|7 - local.get $fl|8 - i32.const 2 - i32.shl - i32.add - local.get $slMap - i32.store offset=4 - i32.const 0 - local.set $sl - loop $for-loop|1 - local.get $sl - i32.const 16 - i32.lt_u - if - local.get $root - local.set $root|11 - local.get $fl - local.set $fl|12 - local.get $sl - local.set $sl|13 - i32.const 0 - local.set $head - local.get $root|11 - local.get $fl|12 - i32.const 4 - i32.shl - local.get $sl|13 - i32.add - i32.const 2 - i32.shl - i32.add - local.get $head - i32.store offset=96 - local.get $sl - i32.const 1 - i32.add - local.set $sl - br $for-loop|1 - end - end - local.get $fl - i32.const 1 - i32.add - local.set $fl - br $for-loop|0 - end - end - local.get $rootOffset - i32.const 1572 - i32.add - local.set $memStart - i32.const 0 - drop - local.get $root - local.get $memStart - memory.size - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - drop - local.get $root - global.set $~lib/rt/tlsf/ROOT - ) - (func $~lib/rt/tlsf/checkUsedBlock (param $ptr i32) (result i32) - (local $block i32) - local.get $ptr - i32.const 4 - i32.sub - local.set $block - local.get $ptr - i32.const 0 - i32.ne - if (result i32) - local.get $ptr - i32.const 15 - i32.and - i32.eqz - else - i32.const 0 - end - if (result i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 1 - i32.and - i32.eqz - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 562 - i32.const 3 - call $~lib/builtins/abort - unreachable - end - local.get $block - return - ) - (func $~lib/rt/tlsf/freeBlock (param $root i32) (param $block i32) - i32.const 0 - drop - local.get $block - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 1 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.get $block - call $~lib/rt/tlsf/insertBlock - ) - (func $~lib/rt/tlsf/__free (param $ptr i32) - local.get $ptr - global.get $~lib/memory/__heap_base - i32.lt_u - if - return - end - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $ptr - call $~lib/rt/tlsf/checkUsedBlock - call $~lib/rt/tlsf/freeBlock - ) - (func $~lib/rt/itcms/free (param $obj i32) - local.get $obj - global.get $~lib/memory/__heap_base - i32.lt_u - if - local.get $obj - i32.const 0 - call $~lib/rt/itcms/Object#set:nextWithColor - local.get $obj - i32.const 0 - call $~lib/rt/itcms/Object#set:prev - else - global.get $~lib/rt/itcms/total - local.get $obj - call $~lib/rt/itcms/Object#get:size - i32.sub - global.set $~lib/rt/itcms/total - i32.const 0 - drop - local.get $obj - i32.const 4 - i32.add - call $~lib/rt/tlsf/__free - end - ) - (func $~lib/rt/itcms/step (result i32) - (local $obj i32) - (local $1 i32) - (local $black i32) - (local $from i32) - block $break|0 - block $case2|0 - block $case1|0 - block $case0|0 - global.get $~lib/rt/itcms/state - local.set $1 - local.get $1 - i32.const 0 - i32.eq - br_if $case0|0 - local.get $1 - i32.const 1 - i32.eq - br_if $case1|0 - local.get $1 - i32.const 2 - i32.eq - br_if $case2|0 - br $break|0 - end - i32.const 1 - global.set $~lib/rt/itcms/state - i32.const 0 - global.set $~lib/rt/itcms/visitCount - i32.const 0 - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/iter - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - global.get $~lib/rt/itcms/white - i32.eqz - local.set $black - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - loop $while-continue|1 - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - global.set $~lib/rt/itcms/iter - local.get $obj - call $~lib/rt/itcms/Object#get:color - local.get $black - i32.ne - if - local.get $obj - local.get $black - call $~lib/rt/itcms/Object#set:color - i32.const 0 - global.set $~lib/rt/itcms/visitCount - local.get $obj - i32.const 20 - i32.add - i32.const 0 - call $~lib/rt/__visit_members - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - local.get $obj - call $~lib/rt/itcms/Object#get:next - local.set $obj - br $while-continue|1 - end - end - i32.const 0 - global.set $~lib/rt/itcms/visitCount - i32.const 0 - call $~lib/rt/itcms/visitRoots - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.eq - if - i32.const 0 - call $~lib/rt/itcms/visitStack - global.get $~lib/rt/itcms/iter - call $~lib/rt/itcms/Object#get:next - local.set $obj - loop $while-continue|2 - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - call $~lib/rt/itcms/Object#get:color - local.get $black - i32.ne - if - local.get $obj - local.get $black - call $~lib/rt/itcms/Object#set:color - local.get $obj - i32.const 20 - i32.add - i32.const 0 - call $~lib/rt/__visit_members - end - local.get $obj - call $~lib/rt/itcms/Object#get:next - local.set $obj - br $while-continue|2 - end - end - global.get $~lib/rt/itcms/fromSpace - local.set $from - global.get $~lib/rt/itcms/toSpace - global.set $~lib/rt/itcms/fromSpace - local.get $from - global.set $~lib/rt/itcms/toSpace - local.get $black - global.set $~lib/rt/itcms/white - local.get $from - call $~lib/rt/itcms/Object#get:next - global.set $~lib/rt/itcms/iter - i32.const 2 - global.set $~lib/rt/itcms/state - end - global.get $~lib/rt/itcms/visitCount - i32.const 1 - i32.mul - return - end - global.get $~lib/rt/itcms/iter - local.set $obj - local.get $obj - global.get $~lib/rt/itcms/toSpace - i32.ne - if - local.get $obj - call $~lib/rt/itcms/Object#get:next - global.set $~lib/rt/itcms/iter - i32.const 1 - drop - local.get $obj - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eqz - i32.eq - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 229 - i32.const 20 - call $~lib/builtins/abort - unreachable - end - local.get $obj - call $~lib/rt/itcms/free - i32.const 10 - return - end - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - call $~lib/rt/itcms/Object#set:nextWithColor - global.get $~lib/rt/itcms/toSpace - global.get $~lib/rt/itcms/toSpace - call $~lib/rt/itcms/Object#set:prev - i32.const 0 - global.set $~lib/rt/itcms/state - br $break|0 - end - i32.const 0 - return - ) - (func $~lib/rt/itcms/interrupt - (local $budget i32) - i32.const 0 - drop - i32.const 0 - drop - i32.const 1024 - i32.const 200 - i32.mul - i32.const 100 - i32.div_u - local.set $budget - loop $do-loop|0 - local.get $budget - call $~lib/rt/itcms/step - i32.sub - local.set $budget - global.get $~lib/rt/itcms/state - i32.const 0 - i32.eq - if - i32.const 0 - drop - global.get $~lib/rt/itcms/total - i64.extend_i32_u - i32.const 200 - i64.extend_i32_u - i64.mul - i64.const 100 - i64.div_u - i32.wrap_i64 - i32.const 1024 - i32.add - global.set $~lib/rt/itcms/threshold - i32.const 0 - drop - return - end - local.get $budget - i32.const 0 - i32.gt_s - br_if $do-loop|0 - end - i32.const 0 - drop - global.get $~lib/rt/itcms/total - i32.const 1024 - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.sub - i32.const 1024 - i32.lt_u - i32.mul - i32.add - global.set $~lib/rt/itcms/threshold - i32.const 0 - drop - ) - (func $~lib/rt/tlsf/computeSize (param $size i32) (result i32) - local.get $size - i32.const 12 - i32.le_u - if (result i32) - i32.const 12 - else - local.get $size - i32.const 4 - i32.add - i32.const 15 - i32.add - i32.const 15 - i32.const -1 - i32.xor - i32.and - i32.const 4 - i32.sub - end - return - ) - (func $~lib/rt/tlsf/prepareSize (param $size i32) (result i32) - local.get $size - i32.const 1073741820 - i32.gt_u - if - i32.const 288 - i32.const 624 - i32.const 461 - i32.const 29 - call $~lib/builtins/abort - unreachable - end - local.get $size - call $~lib/rt/tlsf/computeSize - return - ) - (func $~lib/rt/tlsf/roundSize (param $size i32) (result i32) - local.get $size - i32.const 536870910 - i32.lt_u - if (result i32) - local.get $size - i32.const 1 - i32.const 27 - local.get $size - i32.clz - i32.sub - i32.shl - i32.add - i32.const 1 - i32.sub - else - local.get $size - end - return - ) - (func $~lib/rt/tlsf/searchBlock (param $root i32) (param $size i32) (result i32) - (local $fl i32) - (local $sl i32) - (local $requestSize i32) - (local $root|5 i32) - (local $fl|6 i32) - (local $slMap i32) - (local $head i32) - (local $flMap i32) - (local $root|10 i32) - (local $fl|11 i32) - (local $root|12 i32) - (local $fl|13 i32) - (local $sl|14 i32) - (local $root|15 i32) - (local $fl|16 i32) - (local $sl|17 i32) - local.get $size - i32.const 256 - i32.lt_u - if - i32.const 0 - local.set $fl - local.get $size - i32.const 4 - i32.shr_u - local.set $sl - else - local.get $size - call $~lib/rt/tlsf/roundSize - local.set $requestSize - i32.const 4 - i32.const 8 - i32.mul - i32.const 1 - i32.sub - local.get $requestSize - i32.clz - i32.sub - local.set $fl - local.get $requestSize - local.get $fl - i32.const 4 - i32.sub - i32.shr_u - i32.const 1 - i32.const 4 - i32.shl - i32.xor - local.set $sl - local.get $fl - i32.const 8 - i32.const 1 - i32.sub - i32.sub - local.set $fl - end - i32.const 1 - drop - local.get $fl - i32.const 23 - i32.lt_u - if (result i32) - local.get $sl - i32.const 16 - i32.lt_u - else - i32.const 0 - end - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 334 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETSL|inlined.2 (result i32) - local.get $root - local.set $root|5 - local.get $fl - local.set $fl|6 - local.get $root|5 - local.get $fl|6 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.2 - end - i32.const 0 - i32.const -1 - i32.xor - local.get $sl - i32.shl - i32.and - local.set $slMap - i32.const 0 - local.set $head - local.get $slMap - i32.eqz - if - local.get $root - call $~lib/rt/tlsf/Root#get:flMap - i32.const 0 - i32.const -1 - i32.xor - local.get $fl - i32.const 1 - i32.add - i32.shl - i32.and - local.set $flMap - local.get $flMap - i32.eqz - if - i32.const 0 - local.set $head - else - local.get $flMap - i32.ctz - local.set $fl - block $~lib/rt/tlsf/GETSL|inlined.3 (result i32) - local.get $root - local.set $root|10 - local.get $fl - local.set $fl|11 - local.get $root|10 - local.get $fl|11 - i32.const 2 - i32.shl - i32.add - i32.load offset=4 - br $~lib/rt/tlsf/GETSL|inlined.3 - end - local.set $slMap - i32.const 1 - drop - local.get $slMap - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 347 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - block $~lib/rt/tlsf/GETHEAD|inlined.2 (result i32) - local.get $root - local.set $root|12 - local.get $fl - local.set $fl|13 - local.get $slMap - i32.ctz - local.set $sl|14 - local.get $root|12 - local.get $fl|13 - i32.const 4 - i32.shl - local.get $sl|14 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.2 - end - local.set $head - end - else - block $~lib/rt/tlsf/GETHEAD|inlined.3 (result i32) - local.get $root - local.set $root|15 - local.get $fl - local.set $fl|16 - local.get $slMap - i32.ctz - local.set $sl|17 - local.get $root|15 - local.get $fl|16 - i32.const 4 - i32.shl - local.get $sl|17 - i32.add - i32.const 2 - i32.shl - i32.add - i32.load offset=96 - br $~lib/rt/tlsf/GETHEAD|inlined.3 - end - local.set $head - end - local.get $head - return - ) - (func $~lib/rt/tlsf/growMemory (param $root i32) (param $size i32) - (local $pagesBefore i32) - (local $root|3 i32) - (local $pagesNeeded i32) - (local $5 i32) - (local $6 i32) - (local $pagesWanted i32) - (local $pagesAfter i32) - i32.const 0 - drop - local.get $size - i32.const 256 - i32.ge_u - if - local.get $size - call $~lib/rt/tlsf/roundSize - local.set $size - end - memory.size - local.set $pagesBefore - local.get $size - i32.const 4 - local.get $pagesBefore - i32.const 16 - i32.shl - i32.const 4 - i32.sub - block $~lib/rt/tlsf/GETTAIL|inlined.1 (result i32) - local.get $root - local.set $root|3 - local.get $root|3 - i32.load offset=1568 - br $~lib/rt/tlsf/GETTAIL|inlined.1 - end - i32.ne - i32.shl - i32.add - local.set $size - local.get $size - i32.const 65535 - i32.add - i32.const 65535 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.shr_u - local.set $pagesNeeded - local.get $pagesBefore - local.tee $5 - local.get $pagesNeeded - local.tee $6 - local.get $5 - local.get $6 - i32.gt_s - select - local.set $pagesWanted - local.get $pagesWanted - memory.grow - i32.const 0 - i32.lt_s - if - local.get $pagesNeeded - memory.grow - i32.const 0 - i32.lt_s - if - unreachable - end - end - memory.size - local.set $pagesAfter - local.get $root - local.get $pagesBefore - i32.const 16 - i32.shl - local.get $pagesAfter - i64.extend_i32_s - i64.const 16 - i64.shl - call $~lib/rt/tlsf/addMemory - drop - ) - (func $~lib/rt/tlsf/prepareBlock (param $root i32) (param $block i32) (param $size i32) - (local $blockInfo i32) - (local $remaining i32) - (local $spare i32) - (local $block|6 i32) - (local $block|7 i32) - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - local.set $blockInfo - i32.const 1 - drop - local.get $size - i32.const 4 - i32.add - i32.const 15 - i32.and - i32.eqz - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 361 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $blockInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $size - i32.sub - local.set $remaining - local.get $remaining - i32.const 4 - i32.const 12 - i32.add - i32.ge_u - if - local.get $block - local.get $size - local.get $blockInfo - i32.const 2 - i32.and - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $block - i32.const 4 - i32.add - local.get $size - i32.add - local.set $spare - local.get $spare - local.get $remaining - i32.const 4 - i32.sub - i32.const 1 - i32.or - call $~lib/rt/common/BLOCK#set:mmInfo - local.get $root - local.get $spare - call $~lib/rt/tlsf/insertBlock - else - local.get $block - local.get $blockInfo - i32.const 1 - i32.const -1 - i32.xor - i32.and - call $~lib/rt/common/BLOCK#set:mmInfo - block $~lib/rt/tlsf/GETRIGHT|inlined.3 (result i32) - local.get $block - local.set $block|7 - local.get $block|7 - i32.const 4 - i32.add - local.get $block|7 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.3 - end - block $~lib/rt/tlsf/GETRIGHT|inlined.2 (result i32) - local.get $block - local.set $block|6 - local.get $block|6 - i32.const 4 - i32.add - local.get $block|6 - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.add - br $~lib/rt/tlsf/GETRIGHT|inlined.2 - end - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 2 - i32.const -1 - i32.xor - i32.and - call $~lib/rt/common/BLOCK#set:mmInfo - end - ) - (func $~lib/rt/tlsf/allocateBlock (param $root i32) (param $size i32) (result i32) - (local $payloadSize i32) - (local $block i32) - local.get $size - call $~lib/rt/tlsf/prepareSize - local.set $payloadSize - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/searchBlock - local.set $block - local.get $block - i32.eqz - if - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/growMemory - local.get $root - local.get $payloadSize - call $~lib/rt/tlsf/searchBlock - local.set $block - i32.const 1 - drop - local.get $block - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 499 - i32.const 16 - call $~lib/builtins/abort - unreachable - end - end - i32.const 1 - drop - local.get $block - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - local.get $payloadSize - i32.ge_u - i32.eqz - if - i32.const 0 - i32.const 624 - i32.const 501 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $root - local.get $block - call $~lib/rt/tlsf/removeBlock - local.get $root - local.get $block - local.get $payloadSize - call $~lib/rt/tlsf/prepareBlock - i32.const 0 - drop - local.get $block - return - ) - (func $~lib/rt/tlsf/__alloc (param $size i32) (result i32) - global.get $~lib/rt/tlsf/ROOT - i32.eqz - if - call $~lib/rt/tlsf/initialize - end - global.get $~lib/rt/tlsf/ROOT - local.get $size - call $~lib/rt/tlsf/allocateBlock - i32.const 4 - i32.add - return - ) - (func $~lib/rt/itcms/Object#set:rtId (param $this i32) (param $rtId i32) - local.get $this - local.get $rtId - i32.store offset=12 - ) - (func $~lib/rt/itcms/Object#set:rtSize (param $this i32) (param $rtSize i32) - local.get $this - local.get $rtSize - i32.store offset=16 - ) - (func $~lib/rt/itcms/__new (param $size i32) (param $id i32) (result i32) - (local $obj i32) - (local $ptr i32) - local.get $size - i32.const 1073741804 - i32.ge_u - if - i32.const 288 - i32.const 352 - i32.const 261 - i32.const 31 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/rt/itcms/total - global.get $~lib/rt/itcms/threshold - i32.ge_u - if - call $~lib/rt/itcms/interrupt - end - i32.const 16 - local.get $size - i32.add - call $~lib/rt/tlsf/__alloc - i32.const 4 - i32.sub - local.set $obj - local.get $obj - local.get $id - call $~lib/rt/itcms/Object#set:rtId - local.get $obj - local.get $size - call $~lib/rt/itcms/Object#set:rtSize - local.get $obj - global.get $~lib/rt/itcms/fromSpace - global.get $~lib/rt/itcms/white - call $~lib/rt/itcms/Object#linkTo - global.get $~lib/rt/itcms/total - local.get $obj - call $~lib/rt/itcms/Object#get:size - i32.add - global.set $~lib/rt/itcms/total - local.get $obj - i32.const 20 - i32.add - local.set $ptr - local.get $ptr - i32.const 0 - local.get $size - memory.fill - local.get $ptr - return - ) - (func $assembly/arguments/Args#set:a (param $this i32) (param $a i32) - local.get $this - local.get $a - i32.store - ) - (func $assembly/arguments/Args#set:b (param $this i32) (param $b i32) - local.get $this - local.get $b - i32.store offset=4 - ) - (func $assembly/arguments/Args#set:c (param $this i32) (param $c i32) - local.get $this - local.get $c - i32.store offset=8 - ) - (func $assembly/arguments/Args#set:d (param $this i32) (param $d i32) - local.get $this - local.get $d - i32.store offset=12 - ) - (func $start:assembly/arguments~anonymous|0 (param $_d i32) (param $_l i32) (result i32) - i32.const 0 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - return - ) - (func $~lib/arraybuffer/ArrayBufferView#get:byteLength (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/arraybuffer/ArrayBufferView#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/rt/itcms/__link (param $parentPtr i32) (param $childPtr i32) (param $expectMultiple i32) - (local $child i32) - (local $parent i32) - (local $parentColor i32) - local.get $childPtr - i32.eqz - if - return - end - i32.const 1 - drop - local.get $parentPtr - i32.eqz - if - i32.const 0 - i32.const 352 - i32.const 295 - i32.const 14 - call $~lib/builtins/abort - unreachable - end - local.get $childPtr - i32.const 20 - i32.sub - local.set $child - local.get $child - call $~lib/rt/itcms/Object#get:color - global.get $~lib/rt/itcms/white - i32.eq - if - local.get $parentPtr - i32.const 20 - i32.sub - local.set $parent - local.get $parent - call $~lib/rt/itcms/Object#get:color - local.set $parentColor - local.get $parentColor - global.get $~lib/rt/itcms/white - i32.eqz - i32.eq - if - local.get $expectMultiple - if - local.get $parent - call $~lib/rt/itcms/Object#makeGray - else - local.get $child - call $~lib/rt/itcms/Object#makeGray - end - else - local.get $parentColor - i32.const 3 - i32.eq - if (result i32) - global.get $~lib/rt/itcms/state - i32.const 1 - i32.eq - else - i32.const 0 - end - if - local.get $child - call $~lib/rt/itcms/Object#makeGray - end - end - end - ) - (func $~lib/arraybuffer/ArrayBufferView#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/arguments/Nibbles#set:low (param $this i32) (param $low i32) - local.get $this - local.get $low - i32.store8 - ) - (func $assembly/arguments/Nibbles#set:hig (param $this i32) (param $hig i32) - local.get $this - local.get $hig - i32.store8 offset=1 - ) - (func $assembly/arguments/Nibbles#get:low (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $assembly/arguments/Nibbles#get:hig (param $this i32) (result i32) - local.get $this - i32.load8_u offset=1 - ) - (func $assembly/arguments/Args#get:a (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/arguments/Args#get:b (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $start:assembly/arguments - (local $0 i32) - (local $1 i32) - (local $2 i32) - memory.size - i32.const 16 - i32.shl - global.get $~lib/memory/__heap_base - i32.sub - i32.const 1 - i32.shr_u - global.set $~lib/rt/itcms/threshold - i32.const 400 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/pinSpace - i32.const 432 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/toSpace - i32.const 576 - call $~lib/rt/itcms/initLazy - global.set $~lib/rt/itcms/fromSpace - ) - (func $~lib/math/ipow32 (param $x i32) (param $e i32) (result i32) - (local $out i32) - (local $log i32) - (local $4 i32) - i32.const 1 - local.set $out - i32.const 0 - i32.const 1 - i32.lt_s - drop - local.get $x - i32.const 2 - i32.eq - if - i32.const 1 - local.get $e - i32.shl - i32.const 0 - local.get $e - i32.const 32 - i32.lt_u - select - return - end - local.get $e - i32.const 0 - i32.le_s - if - local.get $x - i32.const -1 - i32.eq - if - i32.const -1 - i32.const 1 - local.get $e - i32.const 1 - i32.and - select - return - end - local.get $e - i32.const 0 - i32.eq - local.get $x - i32.const 1 - i32.eq - i32.or - return - else - local.get $e - i32.const 1 - i32.eq - if - local.get $x - return - else - local.get $e - i32.const 2 - i32.eq - if - local.get $x - local.get $x - i32.mul - return - else - local.get $e - i32.const 32 - i32.lt_s - if - i32.const 32 - local.get $e - i32.clz - i32.sub - local.set $log - block $break|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $log - local.set $4 - local.get $4 - i32.const 5 - i32.eq - br_if $case0|0 - local.get $4 - i32.const 4 - i32.eq - br_if $case1|0 - local.get $4 - i32.const 3 - i32.eq - br_if $case2|0 - local.get $4 - i32.const 2 - i32.eq - br_if $case3|0 - local.get $4 - i32.const 1 - i32.eq - br_if $case4|0 - br $break|0 - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - end - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - end - local.get $out - return - end - end - end - end - loop $while-continue|1 - local.get $e - if - local.get $e - i32.const 1 - i32.and - if - local.get $out - local.get $x - i32.mul - local.set $out - end - local.get $e - i32.const 1 - i32.shr_u - local.set $e - local.get $x - local.get $x - i32.mul - local.set $x - br $while-continue|1 - end - end - local.get $out - return - ) - (func $start:assembly/memory-page - i32.const 2 - i32.const 12 - call $~lib/math/ipow32 - global.set $assembly/memory-page/PAGE_SIZE - i32.const 2 - i32.const 16 - call $~lib/math/ipow32 - global.set $assembly/memory-page/SEGMENT_SIZE - i32.const 2 - i32.const 16 - call $~lib/math/ipow32 - global.set $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/PAGE_SIZE - i32.div_u - global.set $assembly/memory-page/RESERVED_PAGES - i32.const 2 - i32.const 29 - call $~lib/math/ipow32 - global.set $assembly/memory-page/ALLOCATE_EAGERLY - ) - (func $assembly/memory/MaybePageFault#set:isFault (param $this i32) (param $isFault i32) - local.get $this - local.get $isFault - i32.store8 - ) - (func $assembly/memory/MaybePageFault#set:isAccess (param $this i32) (param $isAccess i32) - local.get $this - local.get $isAccess - i32.store8 offset=1 - ) - (func $assembly/memory/MaybePageFault#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store offset=4 - ) - (func $~lib/arraybuffer/ArrayBufferView#set:buffer (param $this i32) (param $buffer i32) - local.get $this - local.get $buffer - i32.store - local.get $this - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/arraybuffer/ArrayBufferView#set:dataStart (param $this i32) (param $dataStart i32) - local.get $this - local.get $dataStart - i32.store offset=4 - ) - (func $~lib/arraybuffer/ArrayBufferView#set:byteLength (param $this i32) (param $byteLength i32) - local.get $this - local.get $byteLength - i32.store offset=8 - ) - (func $assembly/memory-page/Page#set:access (param $this i32) (param $access i32) - local.get $this - local.get $access - i32.store - ) - (func $assembly/memory-page/Page#set:raw (param $this i32) (param $raw i32) - local.get $this - local.get $raw - i32.store offset=4 - local.get $this - local.get $raw - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/RawPage#set:id (param $this i32) (param $id i32) - local.get $this - local.get $id - i32.store - ) - (func $assembly/memory-page/RawPage#set:page (param $this i32) (param $page i32) - local.get $this - local.get $page - i32.store offset=4 - local.get $this - local.get $page - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/instructions/utils/reg (param $v i64) (result i32) - local.get $v - global.get $assembly/registers/NO_OF_REGISTERS - i64.extend_i32_s - i64.ge_u - if (result i32) - global.get $assembly/registers/NO_OF_REGISTERS - i32.const 1 - i32.sub - else - local.get $v - i32.wrap_i64 - end - return - ) - (func $~lib/rt/common/OBJECT#get:rtSize (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 3 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i64) - local.get $this - local.get $index - i32.const 3 - i32.shl - i32.add - local.get $value - i64.store - i32.const 0 - drop - ) - (func $assembly/instructions/outcome/OutcomeData#set:outcome (param $this i32) (param $outcome i32) - local.get $this - local.get $outcome - i32.store - ) - (func $assembly/instructions/outcome/OutcomeData#set:staticJump (param $this i32) (param $staticJump i32) - local.get $this - local.get $staticJump - i32.store offset=4 - ) - (func $assembly/instructions/outcome/OutcomeData#set:dJump (param $this i32) (param $dJump i32) - local.get $this - local.get $dJump - i32.store offset=8 - ) - (func $assembly/instructions/outcome/OutcomeData#set:result (param $this i32) (param $result i32) - local.get $this - local.get $result - i32.store offset=12 - ) - (func $assembly/instructions/outcome/OutcomeData#set:exitCode (param $this i32) (param $exitCode i32) - local.get $this - local.get $exitCode - i32.store offset=16 - ) - (func $assembly/instructions/outcome/ok (result i32) - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - return - ) - (func $assembly/instructions/utils/u8SignExtend (param $v i32) (result i64) - local.get $v - i32.extend8_s - i64.extend_i32_s - return - ) - (func $assembly/instructions/utils/u16SignExtend (param $v i32) (result i64) - local.get $v - i32.extend16_s - i64.extend_i32_s - return - ) - (func $~lib/polyfills/bswap (param $value i64) (result i64) - (local $a i64) - (local $b i64) - (local $v i64) - i32.const 1 - drop - i32.const 8 - i32.const 1 - i32.eq - drop - i32.const 8 - i32.const 2 - i32.eq - drop - i32.const 8 - i32.const 4 - i32.eq - drop - i32.const 8 - i32.const 8 - i32.eq - drop - local.get $value - i64.const 8 - i64.shr_u - i64.const 71777214294589695 - i64.and - local.set $a - local.get $value - i64.const 71777214294589695 - i64.and - i64.const 8 - i64.shl - local.set $b - local.get $a - local.get $b - i64.or - local.set $v - local.get $v - i64.const 16 - i64.shr_u - i64.const 281470681808895 - i64.and - local.set $a - local.get $v - i64.const 281470681808895 - i64.and - i64.const 16 - i64.shl - local.set $b - local.get $a - local.get $b - i64.or - i64.const 32 - i64.rotr - return - ) - (func $assembly/registers/newRegisters (result i32) - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - return - ) - (func $"~lib/map/Map#set:buckets" (param $this i32) (param $buckets i32) - local.get $this - local.get $buckets - i32.store - local.get $this - local.get $buckets - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $"~lib/map/Map#set:bucketsMask" (param $this i32) (param $bucketsMask i32) - local.get $this - local.get $bucketsMask - i32.store offset=4 - ) - (func $"~lib/map/Map#set:entries" (param $this i32) (param $entries i32) - local.get $this - local.get $entries - i32.store offset=8 - local.get $this - local.get $entries - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $"~lib/map/Map#set:entriesCapacity" (param $this i32) (param $entriesCapacity i32) - local.get $this - local.get $entriesCapacity - i32.store offset=12 - ) - (func $"~lib/map/Map#set:entriesOffset" (param $this i32) (param $entriesOffset i32) - local.get $this - local.get $entriesOffset - i32.store offset=16 - ) - (func $"~lib/map/Map#set:entriesCount" (param $this i32) (param $entriesCount i32) - local.get $this - local.get $entriesCount - i32.store offset=20 - ) - (func $assembly/memory/MemoryBuilder#set:pages (param $this i32) (param $pages i32) - local.get $this - local.get $pages - i32.store - local.get $this - local.get $pages - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/Arena#set:arenaBytes (param $this i32) (param $arenaBytes i32) - local.get $this - local.get $arenaBytes - i32.store offset=4 - ) - (func $~lib/rt/__newBuffer (param $size i32) (param $id i32) (param $data i32) (result i32) - (local $buffer i32) - local.get $size - local.get $id - call $~lib/rt/itcms/__new - local.set $buffer - local.get $data - if - local.get $buffer - local.get $data - local.get $size - memory.copy - end - local.get $buffer - return - ) - (func $assembly/memory-page/Arena#set:free (param $this i32) (param $free i32) - local.get $this - local.get $free - i32.store - local.get $this - local.get $free - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory-page/Arena#set:extraPageIndex (param $this i32) (param $extraPageIndex i32) - local.get $this - local.get $extraPageIndex - i32.store offset=8 - ) - (func $assembly/memory-page/Arena#get:arenaBytes (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Arena#get:free (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/arraybuffer/ArrayBuffer#get:byteLength (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - return - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/rt/itcms/Object#get:rtSize (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $~lib/rt/itcms/__renew (param $oldPtr i32) (param $size i32) (result i32) - (local $oldObj i32) - (local $newPtr i32) - (local $4 i32) - (local $5 i32) - local.get $oldPtr - i32.const 20 - i32.sub - local.set $oldObj - local.get $size - local.get $oldObj - call $~lib/rt/common/BLOCK#get:mmInfo - i32.const 3 - i32.const -1 - i32.xor - i32.and - i32.const 16 - i32.sub - i32.le_u - if - local.get $oldObj - local.get $size - call $~lib/rt/itcms/Object#set:rtSize - local.get $oldPtr - return - end - local.get $size - local.get $oldObj - call $~lib/rt/itcms/Object#get:rtId - call $~lib/rt/itcms/__new - local.set $newPtr - local.get $newPtr - local.get $oldPtr - local.get $size - local.tee $4 - local.get $oldObj - call $~lib/rt/itcms/Object#get:rtSize - local.tee $5 - local.get $4 - local.get $5 - i32.lt_u - select - memory.copy - local.get $newPtr - return - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $assembly/memory/MemoryBuilder#set:arena (param $this i32) (param $arena i32) - local.get $this - local.get $arena - i32.store offset=4 - local.get $this - local.get $arena - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/util/hash/HASH (param $key i32) (result i32) - (local $key|1 i32) - (local $len i32) - (local $h i32) - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 4 - i32.const 4 - i32.le_u - drop - block $~lib/util/hash/hash32|inlined.0 (result i32) - local.get $key - local.set $key|1 - i32.const 4 - local.set $len - i32.const 0 - i32.const 374761393 - i32.add - local.get $len - i32.add - local.set $h - local.get $h - local.get $key|1 - i32.const -1028477379 - i32.mul - i32.add - local.set $h - local.get $h - i32.const 17 - i32.rotl - i32.const 668265263 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 15 - i32.shr_u - i32.xor - local.set $h - local.get $h - i32.const -2048144777 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 13 - i32.shr_u - i32.xor - local.set $h - local.get $h - i32.const -1028477379 - i32.mul - local.set $h - local.get $h - local.get $h - i32.const 16 - i32.shr_u - i32.xor - local.set $h - local.get $h - br $~lib/util/hash/hash32|inlined.0 - end - return - ) - (func $"~lib/map/Map#get:buckets" (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $"~lib/map/Map#get:bucketsMask" (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $"~lib/map/MapEntry#get:taggedNext" (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#get:key" (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/Memory#set:lastAllocatedPage (param $this i32) (param $lastAllocatedPage i32) - local.get $this - local.get $lastAllocatedPage - i32.store - ) - (func $assembly/memory/Memory#set:arena (param $this i32) (param $arena i32) - local.get $this - local.get $arena - i32.store offset=4 - local.get $this - local.get $arena - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#set:pages (param $this i32) (param $pages i32) - local.get $this - local.get $pages - i32.store offset=8 - local.get $this - local.get $pages - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#set:sbrkAddress (param $this i32) (param $sbrkAddress i32) - local.get $this - local.get $sbrkAddress - i32.store offset=12 - ) - (func $assembly/memory/MemoryBuilder#get:arena (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/MemoryBuilder#get:pages (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/test/Assert#set:isOkay (param $this i32) (param $isOkay i32) - local.get $this - local.get $isOkay - i32.store8 - ) - (func $assembly/test/Assert#set:errors (param $this i32) (param $errors i32) - local.get $this - local.get $errors - i32.store offset=4 - local.get $this - local.get $errors - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/instructions/outcome/OutcomeData#get:outcome (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/util/number/decimalCount32 (param $value i32) (result i32) - local.get $value - i32.const 100000 - i32.lt_u - if - local.get $value - i32.const 100 - i32.lt_u - if - i32.const 1 - local.get $value - i32.const 10 - i32.ge_u - i32.add - return - else - i32.const 3 - local.get $value - i32.const 10000 - i32.ge_u - i32.add - local.get $value - i32.const 1000 - i32.ge_u - i32.add - return - end - unreachable - else - local.get $value - i32.const 10000000 - i32.lt_u - if - i32.const 6 - local.get $value - i32.const 1000000 - i32.ge_u - i32.add - return - else - i32.const 8 - local.get $value - i32.const 1000000000 - i32.ge_u - i32.add - local.get $value - i32.const 100000000 - i32.ge_u - i32.add - return - end - unreachable - end - unreachable - ) - (func $~lib/util/number/utoa32_dec_lut (param $buffer i32) (param $num i32) (param $offset i32) - (local $t i32) - (local $r i32) - (local $d1 i32) - (local $d2 i32) - (local $digits1 i64) - (local $digits2 i64) - (local $t|9 i32) - (local $d1|10 i32) - (local $digits i32) - (local $digits|12 i32) - (local $digit i32) - loop $while-continue|0 - local.get $num - i32.const 10000 - i32.ge_u - if - local.get $num - i32.const 10000 - i32.div_u - local.set $t - local.get $num - i32.const 10000 - i32.rem_u - local.set $r - local.get $t - local.set $num - local.get $r - i32.const 100 - i32.div_u - local.set $d1 - local.get $r - i32.const 100 - i32.rem_u - local.set $d2 - i32.const 2508 - local.get $d1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 2508 - local.get $d2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $num - i32.const 100 - i32.ge_u - if - local.get $num - i32.const 100 - i32.div_u - local.set $t|9 - local.get $num - i32.const 100 - i32.rem_u - local.set $d1|10 - local.get $t|9 - local.set $num - local.get $offset - i32.const 2 - i32.sub - local.set $offset - i32.const 2508 - local.get $d1|10 - i32.const 2 - i32.shl - i32.add - i32.load - local.set $digits - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits - i32.store - end - local.get $num - i32.const 10 - i32.ge_u - if - local.get $offset - i32.const 2 - i32.sub - local.set $offset - i32.const 2508 - local.get $num - i32.const 2 - i32.shl - i32.add - i32.load - local.set $digits|12 - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits|12 - i32.store - else - local.get $offset - i32.const 1 - i32.sub - local.set $offset - i32.const 48 - local.get $num - i32.add - local.set $digit - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digit - i32.store16 - end - ) - (func $~lib/util/number/utoa_hex_lut (param $buffer i32) (param $num i64) (param $offset i32) - loop $while-continue|0 - local.get $offset - i32.const 2 - i32.ge_u - if - local.get $offset - i32.const 2 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 2928 - local.get $num - i32.wrap_i64 - i32.const 255 - i32.and - i32.const 2 - i32.shl - i32.add - i32.load - i32.store - local.get $num - i64.const 8 - i64.shr_u - local.set $num - br $while-continue|0 - end - end - local.get $offset - i32.const 1 - i32.and - if - local.get $buffer - i32.const 2928 - local.get $num - i32.wrap_i64 - i32.const 6 - i32.shl - i32.add - i32.load16_u - i32.store16 - end - ) - (func $~lib/util/number/ulog_base (param $num i64) (param $base i32) (result i32) - (local $value i32) - (local $b64 i64) - (local $b i64) - (local $e i32) - block $~lib/util/number/isPowerOf2|inlined.0 (result i32) - local.get $base - local.set $value - local.get $value - i32.popcnt - i32.const 1 - i32.eq - br $~lib/util/number/isPowerOf2|inlined.0 - end - if - i32.const 63 - local.get $num - i64.clz - i32.wrap_i64 - i32.sub - i32.const 31 - local.get $base - i32.clz - i32.sub - i32.div_u - i32.const 1 - i32.add - return - end - local.get $base - i64.extend_i32_s - local.set $b64 - local.get $b64 - local.set $b - i32.const 1 - local.set $e - loop $while-continue|0 - local.get $num - local.get $b - i64.ge_u - if - local.get $num - local.get $b - i64.div_u - local.set $num - local.get $b - local.get $b - i64.mul - local.set $b - local.get $e - i32.const 1 - i32.shl - local.set $e - br $while-continue|0 - end - end - loop $while-continue|1 - local.get $num - i64.const 1 - i64.ge_u - if - local.get $num - local.get $b64 - i64.div_u - local.set $num - local.get $e - i32.const 1 - i32.add - local.set $e - br $while-continue|1 - end - end - local.get $e - i32.const 1 - i32.sub - return - ) - (func $~lib/util/number/utoa64_any_core (param $buffer i32) (param $num i64) (param $offset i32) (param $radix i32) - (local $base i64) - (local $shift i64) - (local $mask i64) - (local $q i64) - local.get $radix - i64.extend_i32_s - local.set $base - local.get $radix - local.get $radix - i32.const 1 - i32.sub - i32.and - i32.const 0 - i32.eq - if - local.get $radix - i32.ctz - i32.const 7 - i32.and - i64.extend_i32_s - local.set $shift - local.get $base - i64.const 1 - i64.sub - local.set $mask - loop $do-loop|0 - local.get $offset - i32.const 1 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 3984 - local.get $num - local.get $mask - i64.and - i32.wrap_i64 - i32.const 1 - i32.shl - i32.add - i32.load16_u - i32.store16 - local.get $num - local.get $shift - i64.shr_u - local.set $num - local.get $num - i64.const 0 - i64.ne - br_if $do-loop|0 - end - else - loop $do-loop|1 - local.get $offset - i32.const 1 - i32.sub - local.set $offset - local.get $num - local.get $base - i64.div_u - local.set $q - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - i32.const 3984 - local.get $num - local.get $q - local.get $base - i64.mul - i64.sub - i32.wrap_i64 - i32.const 1 - i32.shl - i32.add - i32.load16_u - i32.store16 - local.get $q - local.set $num - local.get $num - i64.const 0 - i64.ne - br_if $do-loop|1 - end - end - ) - (func $~lib/number/I32#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/itoa32 - return - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/string/String#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 1 - i32.shr_u - return - ) - (func $assembly/test/Assert#get:errors (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array<~lib/string/String>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<~lib/string/String>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array<~lib/string/String>#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/util/number/decimalCount64High (param $value i64) (result i32) - local.get $value - i64.const 1000000000000000 - i64.lt_u - if - local.get $value - i64.const 1000000000000 - i64.lt_u - if - i32.const 10 - local.get $value - i64.const 100000000000 - i64.ge_u - i32.add - local.get $value - i64.const 10000000000 - i64.ge_u - i32.add - return - else - i32.const 13 - local.get $value - i64.const 100000000000000 - i64.ge_u - i32.add - local.get $value - i64.const 10000000000000 - i64.ge_u - i32.add - return - end - unreachable - else - local.get $value - i64.const 100000000000000000 - i64.lt_u - if - i32.const 16 - local.get $value - i64.const 10000000000000000 - i64.ge_u - i32.add - return - else - i32.const 18 - local.get $value - i64.const -8446744073709551616 - i64.ge_u - i32.add - local.get $value - i64.const 1000000000000000000 - i64.ge_u - i32.add - return - end - unreachable - end - unreachable - ) - (func $~lib/util/number/utoa64_dec_lut (param $buffer i32) (param $num i64) (param $offset i32) - (local $t i64) - (local $r i32) - (local $b i32) - (local $c i32) - (local $b1 i32) - (local $b2 i32) - (local $c1 i32) - (local $c2 i32) - (local $digits1 i64) - (local $digits2 i64) - loop $while-continue|0 - local.get $num - i64.const 100000000 - i64.ge_u - if - local.get $num - i64.const 100000000 - i64.div_u - local.set $t - local.get $num - local.get $t - i64.const 100000000 - i64.mul - i64.sub - i32.wrap_i64 - local.set $r - local.get $t - local.set $num - local.get $r - i32.const 10000 - i32.div_u - local.set $b - local.get $r - i32.const 10000 - i32.rem_u - local.set $c - local.get $b - i32.const 100 - i32.div_u - local.set $b1 - local.get $b - i32.const 100 - i32.rem_u - local.set $b2 - local.get $c - i32.const 100 - i32.div_u - local.set $c1 - local.get $c - i32.const 100 - i32.rem_u - local.set $c2 - i32.const 2508 - local.get $c1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 2508 - local.get $c2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - i32.const 2508 - local.get $b1 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits1 - i32.const 2508 - local.get $b2 - i32.const 2 - i32.shl - i32.add - i64.load32_u - local.set $digits2 - local.get $offset - i32.const 4 - i32.sub - local.set $offset - local.get $buffer - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $digits1 - local.get $digits2 - i64.const 32 - i64.shl - i64.or - i64.store - br $while-continue|0 - end - end - local.get $buffer - local.get $num - i32.wrap_i64 - local.get $offset - call $~lib/util/number/utoa32_dec_lut - ) - (func $~lib/number/U64#toString (param $this i64) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/utoa64 - return - ) - (func $assembly/test/Test#set:name (param $this i32) (param $name i32) - local.get $this - local.get $name - i32.store - local.get $this - local.get $name - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/test/Test#set:ptr (param $this i32) (param $ptr i32) - local.get $this - local.get $ptr - i32.store offset=4 - local.get $this - local.get $ptr - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/number/I64#toString (param $this i64) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/itoa64 - return - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/utils/u32SignExtend (param $v i32) (result i64) - local.get $v - i64.extend_i32_s - return - ) - (func $assembly/arguments/Args#get:c (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/instructions/outcome/OutcomeData#get:staticJump (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/number/U32#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - local.get $radix - call $~lib/util/number/utoa32 - return - ) - (func $~lib/math/ipow64 (param $x i64) (param $e i64) (result i64) - (local $out i64) - (local $log i32) - (local $4 i32) - i64.const 1 - local.set $out - i32.const 0 - i32.const 1 - i32.lt_s - drop - local.get $x - i64.const 2 - i64.eq - if - i64.const 1 - local.get $e - i64.shl - i64.const 0 - local.get $e - i64.const 64 - i64.lt_u - select - return - end - local.get $e - i64.const 0 - i64.le_s - if - local.get $x - i64.const -1 - i64.eq - if - i64.const -1 - i64.const 1 - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - select - return - end - local.get $e - i64.const 0 - i64.eq - i64.extend_i32_u - local.get $x - i64.const 1 - i64.eq - i64.extend_i32_u - i64.or - return - else - local.get $e - i64.const 1 - i64.eq - if - local.get $x - return - else - local.get $e - i64.const 2 - i64.eq - if - local.get $x - local.get $x - i64.mul - return - else - local.get $e - i64.const 64 - i64.lt_s - if - i32.const 64 - local.get $e - i64.clz - i32.wrap_i64 - i32.sub - local.set $log - block $break|0 - block $case5|0 - block $case4|0 - block $case3|0 - block $case2|0 - block $case1|0 - block $case0|0 - local.get $log - local.set $4 - local.get $4 - i32.const 6 - i32.eq - br_if $case0|0 - local.get $4 - i32.const 5 - i32.eq - br_if $case1|0 - local.get $4 - i32.const 4 - i32.eq - br_if $case2|0 - local.get $4 - i32.const 3 - i32.eq - br_if $case3|0 - local.get $4 - i32.const 2 - i32.eq - br_if $case4|0 - local.get $4 - i32.const 1 - i32.eq - br_if $case5|0 - br $break|0 - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - end - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - end - local.get $out - return - end - end - end - end - loop $while-continue|1 - local.get $e - i64.const 0 - i64.ne - if - local.get $e - i64.const 1 - i64.and - i64.const 0 - i64.ne - if - local.get $out - local.get $x - i64.mul - local.set $out - end - local.get $e - i64.const 1 - i64.shr_u - local.set $e - local.get $x - local.get $x - i64.mul - local.set $x - br $while-continue|1 - end - end - local.get $out - return - ) - (func $assembly/instructions/utils/mulUpperUnsigned (param $a i64) (param $b i64) (result i64) - (local $aHigh i64) - (local $aLow i64) - (local $bHigh i64) - (local $bLow i64) - (local $lowLow i64) - (local $lowHigh i64) - (local $highLow i64) - (local $highHigh i64) - (local $carry i64) - local.get $a - i64.const 32 - i64.shr_u - local.set $aHigh - local.get $a - i64.const 4294967295 - i64.and - local.set $aLow - local.get $b - i64.const 32 - i64.shr_u - local.set $bHigh - local.get $b - i64.const 4294967295 - i64.and - local.set $bLow - local.get $aLow - local.get $bLow - i64.mul - local.set $lowLow - local.get $aLow - local.get $bHigh - i64.mul - local.set $lowHigh - local.get $aHigh - local.get $bLow - i64.mul - local.set $highLow - local.get $aHigh - local.get $bHigh - i64.mul - local.set $highHigh - local.get $lowLow - i64.const 32 - i64.shr_u - local.get $lowHigh - i64.const 4294967295 - i64.and - i64.add - local.get $highLow - i64.const 4294967295 - i64.and - i64.add - local.set $carry - local.get $highHigh - local.get $lowHigh - i64.const 32 - i64.shr_u - i64.add - local.get $highLow - i64.const 32 - i64.shr_u - i64.add - local.get $carry - i64.const 32 - i64.shr_u - i64.add - return - ) - (func $assembly/instructions/utils/mulUpperSigned (param $a i64) (param $b i64) (result i64) - (local $isResultNegative i32) - (local $aAbs i64) - (local $bAbs i64) - (local $upper i64) - (local $lower i64) - i32.const 0 - local.set $isResultNegative - local.get $a - local.set $aAbs - local.get $b - local.set $bAbs - local.get $a - i64.const 0 - i64.lt_s - if - local.get $isResultNegative - i32.eqz - local.set $isResultNegative - local.get $a - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $aAbs - end - local.get $b - i64.const 0 - i64.lt_s - if - local.get $isResultNegative - i32.eqz - local.set $isResultNegative - local.get $b - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $bAbs - end - local.get $isResultNegative - if - local.get $aAbs - local.get $bAbs - call $assembly/instructions/utils/mulUpperUnsigned - local.set $upper - local.get $aAbs - local.get $bAbs - i64.mul - local.set $lower - local.get $upper - i64.const -1 - i64.xor - local.get $lower - i64.const 0 - i64.eq - if (result i64) - i64.const 1 - else - i64.const 0 - end - i64.add - return - end - local.get $aAbs - local.get $bAbs - call $assembly/instructions/utils/mulUpperUnsigned - return - ) - (func $assembly/instructions/utils/mulUpperSignedUnsigned (param $a i64) (param $b i64) (result i64) - (local $aAbs i64) - (local $upper i64) - (local $lower i64) - local.get $a - i64.const 0 - i64.lt_s - if - local.get $a - i64.const -1 - i64.xor - i64.const 1 - i64.add - local.set $aAbs - local.get $aAbs - local.get $b - call $assembly/instructions/utils/mulUpperUnsigned - local.set $upper - local.get $aAbs - local.get $b - i64.mul - local.set $lower - local.get $upper - i64.const -1 - i64.xor - local.get $lower - i64.const 0 - i64.eq - if (result i64) - i64.const 1 - else - i64.const 0 - end - i64.add - return - end - local.get $a - local.get $b - call $assembly/instructions/utils/mulUpperUnsigned - return - ) - (func $assembly/instructions/rot/math.rot_r (param $v i64) (param $shift i64) (result i64) - local.get $v - local.get $shift - i64.rotr - return - ) - (func $assembly/instructions/rot/math.rot_r_32 (param $v i32) (param $shift i32) (result i32) - local.get $v - local.get $shift - i32.rotr - return - ) - (func $assembly/instructions/rot/math.rot_l (param $v i64) (param $shift i64) (result i64) - local.get $v - local.get $shift - i64.rotl - return - ) - (func $assembly/instructions/rot/math.rot_l_32 (param $v i32) (param $shift i32) (result i32) - local.get $v - local.get $shift - i32.rotl - return - ) - (func $assembly/memory/Chunks#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#set:first (param $this i32) (param $first i32) - local.get $this - local.get $first - i32.store offset=4 - local.get $this - local.get $first - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#set:second (param $this i32) (param $second i32) - local.get $this - local.get $second - i32.store offset=8 - local.get $this - local.get $second - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Memory#get:pages (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/memory/PageData#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/PageData#set:page (param $this i32) (param $page i32) - local.get $this - local.get $page - i32.store offset=4 - local.get $this - local.get $page - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/PageData#set:relativeAddress (param $this i32) (param $relativeAddress i32) - local.get $this - local.get $relativeAddress - i32.store offset=8 - ) - (func $"~lib/map/MapEntry#get:value" (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Page#get:access (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/PageData#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/MaybePageFault#get:isFault (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $assembly/memory/PageData#get:page (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/PageData#get:relativeAddress (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/memory-page/Page#get:raw (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/RawPage#get:page (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/util/bytes/FILL (param $ptr i32) (param $len i32) (param $value i32) (param $start i32) (param $end i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $start - i32.add - local.tee $5 - i32.const 0 - local.tee $6 - local.get $5 - local.get $6 - i32.gt_u - select - else - local.get $start - local.tee $7 - local.get $len - local.tee $8 - local.get $7 - local.get $8 - i32.lt_s - select - end - local.set $start - local.get $end - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $end - i32.add - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_u - select - else - local.get $end - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - end - local.set $end - i32.const 1 - i32.const 1 - i32.eq - drop - local.get $start - local.get $end - i32.lt_s - if - local.get $ptr - local.get $start - i32.add - local.get $value - local.get $end - local.get $start - i32.sub - memory.fill - end - ) - (func $assembly/memory/Chunks#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/ChunkBytes#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/ChunkBytes#set:bytes (param $this i32) (param $bytes i32) - local.get $this - local.get $bytes - i32.store offset=4 - local.get $this - local.get $bytes - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/Chunks#get:first (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/Chunks#get:second (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 0 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - local.get $value - i32.store8 - i32.const 0 - drop - ) - (func $assembly/memory/Result#set:ok (param $this i32) (param $ok i64) - local.get $this - local.get $ok - i64.store - ) - (func $assembly/memory/Result#set:fault (param $this i32) (param $fault i32) - local.get $this - local.get $fault - i32.store offset=8 - local.get $this - local.get $fault - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/memory/ChunkBytes#get:fault (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/ChunkBytes#get:bytes (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory/Result#get:ok (param $this i32) (result i64) - local.get $this - i64.load - ) - (func $assembly/memory/Result#get:fault (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $~lib/number/Bool#toString (param $this i32) (param $radix i32) (result i32) - local.get $this - if (result i32) - i32.const 9040 - else - i32.const 9072 - end - return - ) - (func $assembly/memory/MaybePageFault#get:isAccess (param $this i32) (result i32) - local.get $this - i32.load8_u offset=1 - ) - (func $assembly/memory/MaybePageFault#get:fault (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/memory-page/Arena#get:extraPageIndex (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#set:value" (param $this i32) (param $value i32) - local.get $this - local.get $value - i32.store offset=4 - ) - (func $"~lib/map/Map#get:entriesOffset" (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $"~lib/map/Map#get:entriesCapacity" (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $"~lib/map/Map#get:entriesCount" (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $"~lib/map/Map#get:entries" (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $"~lib/map/MapEntry#set:key" (param $this i32) (param $key i32) - local.get $this - local.get $key - i32.store - ) - (func $"~lib/map/MapEntry#set:taggedNext" (param $this i32) (param $taggedNext i32) - local.get $this - local.get $taggedNext - i32.store offset=8 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i32) (result i32) - (local $sign i32) - (local $dest i32) - (local $decimals i32) - (local $val32 i32) - (local $buffer|6 i32) - (local $num i32) - (local $offset i32) - i32.const 0 - local.set $sign - i32.const 0 - drop - local.get $buffer - local.get $sign - i32.const 1 - i32.shl - i32.add - local.set $dest - i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 0 - drop - local.get $value - i32.const 255 - i32.and - i32.const 10 - i32.lt_u - if - local.get $buffer - local.get $value - i32.const 255 - i32.and - i32.const 48 - i32.or - i32.store16 - i32.const 1 - return - end - i32.const 0 - local.set $decimals - i32.const 1 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 255 - i32.and - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - local.get $dest - local.set $buffer|6 - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|6 - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - local.get $sign - local.get $decimals - i32.add - return - ) - (func $~lib/util/string/compareImpl (param $str1 i32) (param $index1 i32) (param $str2 i32) (param $index2 i32) (param $len i32) (result i32) - (local $ptr1 i32) - (local $ptr2 i32) - (local $7 i32) - (local $a i32) - (local $b i32) - local.get $str1 - local.get $index1 - i32.const 1 - i32.shl - i32.add - local.set $ptr1 - local.get $str2 - local.get $index2 - i32.const 1 - i32.shl - i32.add - local.set $ptr2 - i32.const 0 - i32.const 2 - i32.lt_s - drop - local.get $len - i32.const 4 - i32.ge_u - if (result i32) - local.get $ptr1 - i32.const 7 - i32.and - local.get $ptr2 - i32.const 7 - i32.and - i32.or - i32.eqz - else - i32.const 0 - end - if - block $do-break|0 - loop $do-loop|0 - local.get $ptr1 - i64.load - local.get $ptr2 - i64.load - i64.ne - if - br $do-break|0 - end - local.get $ptr1 - i32.const 8 - i32.add - local.set $ptr1 - local.get $ptr2 - i32.const 8 - i32.add - local.set $ptr2 - local.get $len - i32.const 4 - i32.sub - local.set $len - local.get $len - i32.const 4 - i32.ge_u - br_if $do-loop|0 - end - end - end - loop $while-continue|1 - local.get $len - local.tee $7 - i32.const 1 - i32.sub - local.set $len - local.get $7 - if - local.get $ptr1 - i32.load16_u - local.set $a - local.get $ptr2 - i32.load16_u - local.set $b - local.get $a - local.get $b - i32.ne - if - local.get $a - local.get $b - i32.sub - return - end - local.get $ptr1 - i32.const 2 - i32.add - local.set $ptr1 - local.get $ptr2 - i32.const 2 - i32.add - local.set $ptr2 - br $while-continue|1 - end - end - i32.const 0 - return - ) - (func $assembly/arguments/Args#get:d (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/instructions/outcome/panic (result i32) - global.get $assembly/instructions/outcome/Result.PANIC - call $assembly/instructions/outcome/status - return - ) - (func $start:assembly/instructions/misc~anonymous|0 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/panic - ) - (func $start:assembly/instructions/misc~anonymous|1 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/panic - ) - (func $start:assembly/instructions/misc~anonymous|2 (param $$0 i32) (param $$1 i32) (param $$2 i32) (result i32) - call $assembly/instructions/outcome/ok - ) - (func $assembly/memory/Memory#get:sbrkAddress (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/memory/Memory#get:lastAllocatedPage (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/memory/Memory#get:arena (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/instructions/Instruction#set:namePtr (param $this i32) (param $namePtr i32) - local.get $this - local.get $namePtr - i32.store - ) - (func $assembly/instructions/Instruction#set:kind (param $this i32) (param $kind i32) - local.get $this - local.get $kind - i32.store offset=4 - ) - (func $assembly/instructions/Instruction#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/instructions/Instruction#set:isTerminating (param $this i32) (param $isTerminating i32) - local.get $this - local.get $isTerminating - i32.store8 offset=16 - ) - (func $assembly/instructions/Instruction#constructor (param $this i32) (result i32) - local.get $this - i32.eqz - if - i32.const 17 - call $~lib/rt/tlsf/__alloc - local.set $this - end - local.get $this - i32.const 0 - call $assembly/instructions/Instruction#set:namePtr - local.get $this - global.get $assembly/arguments/Arguments.Zero - call $assembly/instructions/Instruction#set:kind - local.get $this - i64.const 0 - call $assembly/instructions/Instruction#set:gas - local.get $this - i32.const 0 - call $assembly/instructions/Instruction#set:isTerminating - local.get $this - ) - (func $assembly/instructions/instruction (param $name i32) (param $kind i32) (param $gas i64) (param $isTerminating i32) (result i32) - (local $i i32) - i32.const 0 - call $assembly/instructions/Instruction#constructor - local.set $i - local.get $i - local.get $name - call $assembly/instructions/Instruction#set:namePtr - local.get $i - local.get $kind - call $assembly/instructions/Instruction#set:kind - local.get $i - local.get $gas - call $assembly/instructions/Instruction#set:gas - local.get $i - local.get $isTerminating - call $assembly/instructions/Instruction#set:isTerminating - local.get $i - return - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $start:assembly/program - call $start:assembly/instructions - ) - (func $assembly/program/Mask#set:bytesToSkip (param $this i32) (param $bytesToSkip i32) - local.get $this - local.get $bytesToSkip - i32.store - local.get $this - local.get $bytesToSkip - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Mask#get:bytesToSkip (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i32) (result i32) - (local $sign i32) - (local $dest i32) - (local $decimals i32) - (local $val32 i32) - (local $buffer|6 i32) - (local $num i32) - (local $offset i32) - i32.const 0 - local.set $sign - i32.const 0 - drop - local.get $buffer - local.get $sign - i32.const 1 - i32.shl - i32.add - local.set $dest - i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 0 - drop - local.get $value - i32.const 10 - i32.lt_u - if - local.get $buffer - local.get $value - i32.const 48 - i32.or - i32.store16 - i32.const 1 - return - end - i32.const 0 - local.set $decimals - i32.const 4 - i32.const 4 - i32.le_u - drop - local.get $value - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - local.get $dest - local.set $buffer|6 - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|6 - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - local.get $sign - local.get $decimals - i32.add - return - ) - (func $~lib/string/String#toString (param $this i32) (result i32) - local.get $this - return - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/Decoder#set:source (param $this i32) (param $source i32) - local.get $this - local.get $source - i32.store - local.get $this - local.get $source - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/codec/Decoder#set:offset (param $this i32) (param $offset i32) - local.get $this - local.get $offset - i32.store offset=4 - ) - (func $assembly/codec/Decoder#get:offset (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/Decoder#get:source (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/codec/ValOffset#set:value (param $this i32) (param $value i32) - local.get $this - local.get $value - i32.store - ) - (func $assembly/codec/ValOffset#set:offset (param $this i32) (param $offset i32) - local.get $this - local.get $offset - i32.store offset=4 - ) - (func $assembly/codec/ValOffset#get:offset (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/codec/ValOffset#get:value (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/JumpTable#set:jumps (param $this i32) (param $jumps i32) - local.get $this - local.get $jumps - i32.store - local.get $this - local.get $jumps - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $~lib/staticarray/StaticArray#get:length (param $this i32) (result i32) - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.const 2 - i32.shr_u - return - ) - (func $~lib/staticarray/StaticArray#__uset (param $this i32) (param $index i32) (param $value i32) - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - ) - (func $assembly/instructions/Instruction#get:isTerminating (param $this i32) (result i32) - local.get $this - i32.load8_u offset=16 - ) - (func $assembly/program/BasicBlocks#set:isStartOrEnd (param $this i32) (param $isStartOrEnd i32) - local.get $this - local.get $isStartOrEnd - i32.store - local.get $this - local.get $isStartOrEnd - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:code (param $this i32) (param $code i32) - local.get $this - local.get $code - i32.store - local.get $this - local.get $code - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:mask (param $this i32) (param $mask i32) - local.get $this - local.get $mask - i32.store offset=4 - local.get $this - local.get $mask - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:jumpTable (param $this i32) (param $jumpTable i32) - local.get $this - local.get $jumpTable - i32.store offset=8 - local.get $this - local.get $jumpTable - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#set:basicBlocks (param $this i32) (param $basicBlocks i32) - local.get $this - local.get $basicBlocks - i32.store offset=12 - local.get $this - local.get $basicBlocks - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/program/Program#get:mask (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/program/Program#get:jumpTable (param $this i32) (result i32) - local.get $this - i32.load offset=8 - ) - (func $assembly/program/JumpTable#get:jumps (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/program/Program#get:basicBlocks (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $assembly/program/BasicBlocks#get:isStartOrEnd (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ (param $this i32) (result i32) - local.get $this - i32.load offset=12 - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/array/Array#set:length_ (param $this i32) (param $length_ i32) - local.get $this - local.get $length_ - i32.store offset=12 - ) - (func $start:assembly/spi - i32.const 2 - i32.const 24 - call $~lib/math/ipow32 - global.set $assembly/spi/MAX_ARGS_LEN - i32.const 2 - i32.const 32 - call $~lib/math/ipow32 - global.get $assembly/memory-page/SEGMENT_SIZE - i32.sub - global.get $assembly/spi/MAX_ARGS_LEN - i32.sub - global.set $assembly/spi/ARGS_SEGMENT_START - global.get $assembly/spi/ARGS_SEGMENT_START - global.get $assembly/memory-page/SEGMENT_SIZE - i32.sub - global.set $assembly/spi/STACK_SEGMENT_END - ) - (func $assembly/spi/alignToSegmentSize (param $size i32) (result i32) - local.get $size - global.get $assembly/memory-page/SEGMENT_SIZE - i32.add - i32.const 1 - i32.sub - global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT - i32.shr_u - global.get $assembly/memory-page/SEGMENT_SIZE_SHIFT - i32.shl - return - ) - (func $assembly/spi/alignToPageSize (param $size i32) (result i32) - local.get $size - global.get $assembly/memory-page/PAGE_SIZE - i32.add - i32.const 1 - i32.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - return - ) - (func $assembly/spi/StandardProgram#set:program (param $this i32) (param $program i32) - local.get $this - local.get $program - i32.store offset=16 - local.get $this - local.get $program - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:memory (param $this i32) (param $memory i32) - local.get $this - local.get $memory - i32.store offset=20 - local.get $this - local.get $memory - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:registers (param $this i32) (param $registers i32) - local.get $this - local.get $registers - i32.store offset=24 - local.get $this - local.get $registers - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:metadata (param $this i32) (param $metadata i32) - local.get $this - local.get $metadata - i32.store - local.get $this - local.get $metadata - i32.const 0 - call $~lib/rt/itcms/__link - ) - (func $assembly/spi/StandardProgram#set:pc (param $this i32) (param $pc i32) - local.get $this - local.get $pc - i32.store offset=4 - ) - (func $assembly/spi/StandardProgram#set:gas (param $this i32) (param $gas i64) - local.get $this - local.get $gas - i64.store offset=8 - ) - (func $assembly/spi/StandardProgram#get:program (param $this i32) (result i32) - local.get $this - i32.load offset=16 - ) - (func $assembly/program/Program#get:code (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/spi/StandardProgram#get:memory (param $this i32) (result i32) - local.get $this - i32.load offset=20 - ) - (func $assembly/spi/StandardProgram#get:registers (param $this i32) (result i32) - local.get $this - i32.load offset=24 - ) - (func $~lib/util/number/itoa_buffered (param $buffer i32) (param $value i64) (result i32) - (local $sign i32) - (local $dest i32) - (local $decimals i32) - (local $val32 i32) - (local $buffer|6 i32) - (local $num i32) - (local $offset i32) - (local $val64 i64) - (local $buffer|10 i32) - (local $num|11 i64) - (local $offset|12 i32) - i32.const 0 - local.set $sign - i32.const 0 - drop - local.get $buffer - local.get $sign - i32.const 1 - i32.shl - i32.add - local.set $dest - i32.const 0 - i32.const 1 - i32.le_s - drop - i32.const 0 - drop - local.get $value - i64.const 10 - i64.lt_u - if - local.get $buffer - local.get $value - i32.const 48 - i64.extend_i32_s - i64.or - i64.store16 - i32.const 1 - return - end - i32.const 0 - local.set $decimals - i32.const 8 - i32.const 4 - i32.le_u - drop - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - local.get $dest - local.set $buffer|6 - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|6 - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - local.set $val64 - local.get $val64 - call $~lib/util/number/decimalCount64High - local.set $decimals - local.get $dest - local.set $buffer|10 - local.get $val64 - local.set $num|11 - local.get $decimals - local.set $offset|12 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|10 - local.get $num|11 - local.get $offset|12 - call $~lib/util/number/utoa64_dec_lut - end - local.get $sign - local.get $decimals - i32.add - return - ) - (func $start:assembly/test-run - call $start:assembly/instructions/bit.test - call $start:assembly/instructions/branch.test - call $start:assembly/instructions/logic.test - call $start:assembly/instructions/math.test - call $start:assembly/instructions/rot.test - call $start:assembly/memory.test - call $start:assembly/program.test - call $start:assembly/spi.test - ) - (func $assembly/test/Test#get:name (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $assembly/test/Test#get:ptr (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $assembly/test/Assert#get:isOkay (param $this i32) (result i32) - local.get $this - i32.load8_u - ) - (func $~lib/rt/__visit_globals (param $0 i32) - (local $1 i32) - i32.const 480 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 1296 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 9584 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 21616 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 8624 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 288 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 2928 - local.get $0 - call $~lib/rt/itcms/__visit - i32.const 3984 - local.get $0 - call $~lib/rt/itcms/__visit - global.get $assembly/instructions/bit.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/branch.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/logic.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/math.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/rot.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/program.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/spi.test/TESTS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/RELEVANT_ARGS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/REQUIRED_BYTES - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/arguments/DECODERS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/NO_PAGE_FAULT - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/memory/EMPTY_PAGE - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions-exe/RUN - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/codec/MASKS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - global.get $assembly/instructions/INSTRUCTIONS - local.tee $1 - if - local.get $1 - local.get $0 - call $~lib/rt/itcms/__visit - end - ) - (func $~lib/arraybuffer/ArrayBufferView~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/object/Object~visit (param $0 i32) (param $1 i32) - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/typedarray/Uint8Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit - ) - (func $assembly/memory-page/Page~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory-page/RawPage~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/Memory~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory-page/Arena~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $"~lib/map/Map~visit" (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $"~lib/map/Map#__visit" - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit - ) - (func $assembly/test/Test~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/test/Assert~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array<~lib/string/String>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<~lib/string/String>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/memory/MemoryBuilder~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - i32.const 1 - drop - local.get $this - local.set $cur - local.get $cur - local.get $this - i32.const 20 - i32.sub - call $~lib/rt/common/OBJECT#get:rtSize - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray<~lib/string/String>#__visit - ) - (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#__visit - ) - (func $assembly/memory/Result~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/ChunkBytes~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/Chunks~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/memory/PageData~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/typedarray/Uint8ClampedArray~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/function/Function<%28u8%29=>u8>#get:_env (param $this i32) (result i32) - local.get $this - i32.load offset=4 - ) - (func $~lib/function/Function<%28u8%29=>u8>~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/function/Function<%28u8%29=>u8>#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/program/Mask~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $~lib/array/Array#get:buffer (param $this i32) (result i32) - local.get $this - i32.load - ) - (func $~lib/array/Array~visit (param $0 i32) (param $1 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - local.get $1 - call $~lib/array/Array#__visit - ) - (func $assembly/program/Program~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=4 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=8 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=12 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/JumpTable~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/program/BasicBlocks~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/codec/Decoder~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $assembly/spi/StandardProgram~visit (param $0 i32) (param $1 i32) - (local $2 i32) - local.get $0 - local.get $1 - call $~lib/object/Object~visit - local.get $0 - i32.load - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=16 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=20 - local.get $1 - call $~lib/rt/itcms/__visit - local.get $0 - i32.load offset=24 - local.get $1 - call $~lib/rt/itcms/__visit - ) - (func $~lib/rt/__visit_members (param $0 i32) (param $1 i32) - block $invalid - block $assembly/spi/StandardProgram - block $assembly/codec/ValOffset - block $assembly/codec/Decoder - block $~lib/staticarray/StaticArray - block $assembly/program/BasicBlocks - block $assembly/program/JumpTable - block $assembly/program/Program - block $~lib/array/Array - block $~lib/array/Array - block $~lib/staticarray/StaticArray - block $assembly/program/Mask - block $~lib/array/Array - block $~lib/function/Function<%28u8%29=>u8> - block $~lib/array/Array - block $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> - block $~lib/typedarray/Uint8ClampedArray - block $assembly/memory/PageData - block $assembly/memory/Chunks - block $~lib/staticarray/StaticArray - block $assembly/memory/ChunkBytes - block $assembly/memory/Result - block $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert> - block $~lib/staticarray/StaticArray<~lib/string/String> - block $assembly/memory/MemoryBuilder - block $~lib/array/Array - block $~lib/array/Array<~lib/string/String> - block $assembly/test/Assert - block $assembly/test/Test - block $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> - block $assembly/instructions/outcome/OutcomeData - block $"~lib/map/Map" - block $~lib/array/Array - block $assembly/memory-page/Arena - block $assembly/memory/Memory - block $~lib/staticarray/StaticArray - block $assembly/memory-page/RawPage - block $assembly/memory-page/Page - block $assembly/memory/MaybePageFault - block $assembly/arguments/Nibbles - block $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> - block $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> - block $assembly/arguments/Args - block $~lib/typedarray/Uint8Array - block $~lib/array/Array - block $~lib/arraybuffer/ArrayBufferView - block $~lib/string/String - block $~lib/arraybuffer/ArrayBuffer - block $~lib/object/Object - local.get $0 - i32.const 8 - i32.sub - i32.load - br_table $~lib/object/Object $~lib/arraybuffer/ArrayBuffer $~lib/string/String $~lib/arraybuffer/ArrayBufferView $~lib/array/Array $~lib/typedarray/Uint8Array $assembly/arguments/Args $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args> $assembly/arguments/Nibbles $assembly/memory/MaybePageFault $assembly/memory-page/Page $assembly/memory-page/RawPage $~lib/staticarray/StaticArray $assembly/memory/Memory $assembly/memory-page/Arena $~lib/array/Array $"~lib/map/Map" $assembly/instructions/outcome/OutcomeData $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $assembly/test/Test $assembly/test/Assert $~lib/array/Array<~lib/string/String> $~lib/array/Array $assembly/memory/MemoryBuilder $~lib/staticarray/StaticArray<~lib/string/String> $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert> $assembly/memory/Result $assembly/memory/ChunkBytes $~lib/staticarray/StaticArray $assembly/memory/Chunks $assembly/memory/PageData $~lib/typedarray/Uint8ClampedArray $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData> $~lib/array/Array $~lib/function/Function<%28u8%29=>u8> $~lib/array/Array $assembly/program/Mask $~lib/staticarray/StaticArray $~lib/array/Array $~lib/array/Array $assembly/program/Program $assembly/program/JumpTable $assembly/program/BasicBlocks $~lib/staticarray/StaticArray $assembly/codec/Decoder $assembly/codec/ValOffset $assembly/spi/StandardProgram $invalid - end - return - end - return - end - return - end - local.get $0 - local.get $1 - call $~lib/arraybuffer/ArrayBufferView~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/typedarray/Uint8Array~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>~visit - return - end - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/Page~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/RawPage~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory/Memory~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory-page/Arena~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $"~lib/map/Map~visit" - return - end - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit - return - end - local.get $0 - local.get $1 - call $assembly/test/Test~visit - return - end - local.get $0 - local.get $1 - call $assembly/test/Assert~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/MemoryBuilder~visit - return - end - local.get $0 - local.get $1 - call $~lib/staticarray/StaticArray<~lib/string/String>~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/Result~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/ChunkBytes~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/memory/Chunks~visit - return - end - local.get $0 - local.get $1 - call $assembly/memory/PageData~visit - return - end - local.get $0 - local.get $1 - call $~lib/typedarray/Uint8ClampedArray~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/function/Function<%28u8%29=>u8>~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/Mask~visit - return - end - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $~lib/array/Array~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/Program~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/JumpTable~visit - return - end - local.get $0 - local.get $1 - call $assembly/program/BasicBlocks~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/codec/Decoder~visit - return - end - return - end - local.get $0 - local.get $1 - call $assembly/spi/StandardProgram~visit - return - end - unreachable - ) - (func $~start - call $start:assembly/test-run - ) - (func $~stack_check - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__data_end - i32.lt_s - if - i32.const 60960 - i32.const 61008 - i32.const 1 - i32.const 1 - call $~lib/builtins/abort - unreachable - end - ) - (func $assembly/arguments/Args#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 6 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:b - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:c - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Args#set:d - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/arguments/Args.from (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32) - (local $x i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $x - i32.store - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $a - call $assembly/arguments/Args#set:a - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $b - call $assembly/arguments/Args#set:b - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $c - call $assembly/arguments/Args#set:c - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $d - call $assembly/arguments/Args#set:d - local.get $x - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/typedarray/Uint8Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/typedarray/Uint8Array#subarray (param $this i32) (param $begin i32) (param $end i32) (result i32) - (local $array i32) - (local $begin|4 i32) - (local $end|5 i32) - (local $len i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $14 i32) - (local $15 i32) - (local $16 i32) - (local $out i32) - (local $buf i32) - (local $19 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - block $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $array - i32.store - local.get $begin - local.set $begin|4 - local.get $end - local.set $end|5 - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - local.get $begin|4 - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $begin|4 - i32.add - local.tee $7 - i32.const 0 - local.tee $8 - local.get $7 - local.get $8 - i32.gt_s - select - else - local.get $begin|4 - local.tee $9 - local.get $len - local.tee $10 - local.get $9 - local.get $10 - i32.lt_s - select - end - local.set $begin|4 - local.get $end|5 - i32.const 0 - i32.lt_s - if (result i32) - local.get $len - local.get $end|5 - i32.add - local.tee $11 - i32.const 0 - local.tee $12 - local.get $11 - local.get $12 - i32.gt_s - select - else - local.get $end|5 - local.tee $13 - local.get $len - local.tee $14 - local.get $13 - local.get $14 - i32.lt_s - select - end - local.set $end|5 - local.get $end|5 - local.tee $15 - local.get $begin|4 - local.tee $16 - local.get $15 - local.get $16 - i32.gt_s - select - local.set $end|5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=8 - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $buf - local.get $out - local.get $buf - i32.store - local.get $out - local.get $buf - i32.const 0 - call $~lib/rt/itcms/__link - local.get $out - local.get $array - local.set $19 - global.get $~lib/memory/__stack_pointer - local.get $19 - i32.store offset=4 - local.get $19 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $begin|4 - i32.const 0 - i32.shl - i32.add - i32.store offset=4 - local.get $out - local.get $end|5 - local.get $begin|4 - i32.sub - i32.const 0 - i32.shl - i32.store offset=8 - local.get $out - br $"~lib/typedarray/SUBARRAY<~lib/typedarray/Uint8Array,u8>|inlined.0" - end - local.set $19 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $19 - return - ) - (func $~lib/typedarray/Uint8Array#__get (param $this i32) (param $index i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - i32.ge_u - if - i32.const 480 - i32.const 720 - i32.const 167 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $index - i32.add - i32.load8_u - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/arguments/decodeI32 (param $input i32) (param $start i32) (param $end i32) (result i32) - (local $data i32) - (local $value1 f64) - (local $value2 f64) - (local $len i32) - (local $num i32) - (local $i i32) - (local $msb i32) - (local $prefix i32) - (local $i|11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $input - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $start - local.get $end - local.get $start - i32.gt_u - if (result i32) - local.get $end - else - local.get $start - end - call $~lib/typedarray/Uint8Array#subarray - local.tee $data - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.0 (result f64) - f64.const 4 - local.set $value1 - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - f64.convert_i32_s - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.0 - end - i32.trunc_sat_f64_u - local.set $len - i32.const 0 - local.set $num - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_u - if - local.get $num - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.get $i - i32.const 8 - i32.mul - i32.shl - i32.or - local.set $num - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $len - i32.const 0 - i32.gt_u - if (result i32) - local.get $data - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $len - i32.const 1 - i32.sub - call $~lib/typedarray/Uint8Array#__get - i32.const 128 - i32.and - else - i32.const 0 - end - local.set $msb - local.get $msb - i32.const 0 - i32.gt_u - if (result i32) - i32.const 255 - else - i32.const 0 - end - local.set $prefix - local.get $len - local.set $i|11 - loop $for-loop|1 - local.get $i|11 - i32.const 4 - i32.lt_u - if - local.get $num - local.get $prefix - local.get $i|11 - i32.const 8 - i32.mul - i32.shl - i32.or - local.set $num - local.get $i|11 - i32.const 1 - i32.add - local.set $i|11 - br $for-loop|1 - end - end - local.get $num - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $start:assembly/arguments~anonymous|1 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/arguments/Nibbles#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 2 - i32.const 9 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Nibbles#set:low - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/arguments/Nibbles#set:hig - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $assembly/arguments/nibbles (param $byte i32) (result i32) - (local $low i32) - (local $hig i32) - (local $n i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $byte - i32.const 15 - i32.and - local.set $low - local.get $byte - i32.const 255 - i32.and - i32.const 4 - i32.const 7 - i32.and - i32.shr_u - local.set $hig - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Nibbles#constructor - local.tee $n - i32.store - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $low - call $assembly/arguments/Nibbles#set:low - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $hig - call $assembly/arguments/Nibbles#set:hig - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/arguments/twoImm (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $first i32) - (local $second i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.1 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.1 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $first - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $second - local.get $first - local.get $second - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|2 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $lim - call $assembly/arguments/twoImm - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $start:assembly/arguments~anonymous|3 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/arguments~anonymous|4 (param $data i32) (param $lim i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/typedarray/Uint8Array#subarray@varargs (param $this i32) (param $begin i32) (param $end i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $begin - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $begin - local.get $end - call $~lib/typedarray/Uint8Array#subarray - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/arguments/decodeU32 (param $data i32) (result i32) - (local $num i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 2 - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $num - local.get $num - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 3 - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - local.set $num - local.get $num - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/arguments~anonymous|5 (param $data i32) (param $_lim i32) (result i32) - (local $a i32) - (local $b i32) - (local $c i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Nibbles#get:low - local.set $a - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 1 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/decodeU32 - local.set $b - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 5 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/decodeU32 - local.set $c - local.get $a - i32.const 255 - i32.and - local.get $b - local.get $c - i32.const 0 - call $assembly/arguments/Args.from - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/arguments~anonymous|6 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $immA i32) - (local $immB i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.2 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.2 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $immA - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $immB - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $immA - local.get $immB - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|7 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $value1 f64) - (local $value2 f64) - (local $split i32) - (local $immA i32) - (local $offs i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - block $~lib/math/NativeMath.min|inlined.3 (result f64) - f64.const 4 - local.set $value1 - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - f64.convert_i32_u - local.set $value2 - local.get $value1 - local.get $value2 - f64.min - br $~lib/math/NativeMath.min|inlined.3 - end - i32.trunc_sat_f64_s - i32.const 1 - i32.add - local.set $split - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $split - call $assembly/arguments/decodeI32 - local.set $immA - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $split - local.get $lim - call $assembly/arguments/decodeI32 - local.set $offs - local.get $n - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $immA - local.get $offs - i32.const 0 - call $assembly/arguments/Args.from - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/arguments~anonymous|8 (param $data i32) (param $_lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - i32.const 0 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|9 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|10 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 1 - local.get $lim - call $assembly/arguments/decodeI32 - i32.const 0 - call $assembly/arguments/Args.from - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/arguments~anonymous|11 (param $data i32) (param $lim i32) (result i32) - (local $n i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $n - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - i32.const 1 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $lim - i32.const 1 - i32.gt_u - if (result i32) - local.get $lim - i32.const 1 - i32.sub - else - i32.const 0 - end - call $assembly/arguments/twoImm - local.tee $result - i32.store offset=12 - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $n - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:a - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/arguments/Args.from - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/arguments~anonymous|12 (param $data i32) (param $_lim i32) (result i32) - (local $a i32) - (local $b i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $a - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - call $~lib/typedarray/Uint8Array#__get - call $assembly/arguments/nibbles - local.tee $b - i32.store offset=8 - local.get $a - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:hig - i32.const 255 - i32.and - local.get $a - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - local.get $b - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Nibbles#get:low - i32.const 255 - i32.and - i32.const 0 - call $assembly/arguments/Args.from - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/MaybePageFault#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 10 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:isFault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:isAccess - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#set:fault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/arraybuffer/ArrayBufferView#constructor (param $this i32) (param $length i32) (param $alignLog2 i32) (result i32) - (local $buffer i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 3 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:buffer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#set:byteLength - local.get $length - i32.const 1073741820 - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1344 - i32.const 19 - i32.const 57 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $length - local.get $alignLog2 - i32.shl - local.tee $length - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store offset=8 - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $buffer - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $~lib/arraybuffer/ArrayBufferView#set:buffer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $buffer - call $~lib/arraybuffer/ArrayBufferView#set:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $length - call $~lib/arraybuffer/ArrayBufferView#set:byteLength - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $~lib/typedarray/Uint8Array#constructor (param $this i32) (param $length i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $length - i32.const 0 - call $~lib/arraybuffer/ArrayBufferView#constructor - local.tee $this - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/memory-page/Page#constructor (param $this i32) (param $access i32) (param $raw i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 11 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $access - call $assembly/memory-page/Page#set:access - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $raw - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory-page/Page#set:raw - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory-page/RawPage#constructor (param $this i32) (param $id i32) (param $page i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 12 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $id - call $assembly/memory-page/RawPage#set:id - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $page - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory-page/RawPage#set:page - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $start:assembly/memory - (local $0 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - call $start:assembly/memory-page - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - global.set $assembly/memory/NO_PAGE_FAULT - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - global.set $assembly/memory/EMPTY_UINT8ARRAY - i32.const 0 - global.get $assembly/memory-page/Access.None - i32.const 0 - i32.const -1 - i32.const 0 - call $assembly/memory-page/RawPage#constructor - local.set $0 - global.get $~lib/memory/__stack_pointer - local.get $0 - i32.store - local.get $0 - call $assembly/memory-page/Page#constructor - global.set $assembly/memory/EMPTY_PAGE - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i64) - (local $value i64) - (local $3 i32) - (local $4 i64) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/OutcomeData#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.const 18 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/instructions/outcome/Outcome.Ok - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:staticJump - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:dJump - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - global.get $assembly/instructions/outcome/Result.PANIC - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#set:exitCode - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $start:assembly/instructions/bit~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.popcnt - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.popcnt - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.clz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.clz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ctz - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.ctz - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u8SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u16SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|8 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i32.const 65535 - i32.and - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/bit~anonymous|9 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/polyfills/bswap - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $"~lib/map/Map#constructor" (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.const 17 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 4 - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - i32.const 1 - i32.sub - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 4 - block $"~lib/map/ENTRY_SIZE|inlined.0" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.0" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4 - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesOffset" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/typedarray/Uint8Array.wrap (param $buffer i32) (param $byteOffset i32) (param $length i32) (result i32) - (local $buffer|3 i32) - (local $byteOffset|4 i32) - (local $len i32) - (local $byteLength i32) - (local $bufferByteLength i32) - (local $out i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - block $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" (result i32) - global.get $~lib/memory/__stack_pointer - local.get $buffer - local.tee $buffer|3 - i32.store - local.get $byteOffset - local.set $byteOffset|4 - local.get $length - local.set $len - local.get $buffer|3 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/arraybuffer/ArrayBuffer#get:byteLength - local.set $bufferByteLength - local.get $byteOffset|4 - local.get $bufferByteLength - i32.gt_u - local.get $byteOffset|4 - i32.const 0 - i32.and - i32.or - if - i32.const 480 - i32.const 720 - i32.const 1860 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $len - i32.const 0 - i32.lt_s - if - local.get $len - i32.const -1 - i32.eq - if - local.get $bufferByteLength - i32.const 0 - i32.and - if - i32.const 1296 - i32.const 720 - i32.const 1865 - i32.const 9 - call $~lib/builtins/abort - unreachable - end - local.get $bufferByteLength - local.get $byteOffset|4 - i32.sub - local.set $byteLength - else - i32.const 1296 - i32.const 720 - i32.const 1869 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - else - local.get $len - i32.const 0 - i32.shl - local.set $byteLength - local.get $byteOffset|4 - local.get $byteLength - i32.add - local.get $bufferByteLength - i32.gt_s - if - i32.const 1296 - i32.const 720 - i32.const 1874 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 5 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=8 - local.get $out - local.get $buffer|3 - i32.store - local.get $out - local.get $buffer|3 - i32.const 0 - call $~lib/rt/itcms/__link - local.get $out - local.get $byteLength - i32.store offset=8 - local.get $out - local.get $buffer|3 - local.get $byteOffset|4 - i32.add - i32.store offset=4 - local.get $out - br $"~lib/typedarray/WRAP<~lib/typedarray/Uint8Array,u8>|inlined.0" - end - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $~lib/array/ensureCapacity (param $array i32) (param $newSize i32) (param $alignLog2 i32) (param $canGrow i32) - (local $oldCapacity i32) - (local $oldData i32) - (local $6 i32) - (local $7 i32) - (local $newCapacity i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $newData i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $array - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - local.set $oldCapacity - local.get $newSize - local.get $oldCapacity - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - local.get $newSize - i32.const 1073741820 - local.get $alignLog2 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1888 - i32.const 19 - i32.const 48 - call $~lib/builtins/abort - unreachable - end - local.get $array - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store - local.get $14 - call $~lib/arraybuffer/ArrayBufferView#get:buffer - local.set $oldData - local.get $newSize - local.tee $6 - i32.const 8 - local.tee $7 - local.get $6 - local.get $7 - i32.gt_u - select - local.get $alignLog2 - i32.shl - local.set $newCapacity - local.get $canGrow - if - local.get $oldCapacity - i32.const 1 - i32.shl - local.tee $9 - i32.const 1073741820 - local.tee $10 - local.get $9 - local.get $10 - i32.lt_u - select - local.tee $11 - local.get $newCapacity - local.tee $12 - local.get $11 - local.get $12 - i32.gt_u - select - local.set $newCapacity - end - local.get $oldData - local.get $newCapacity - call $~lib/rt/itcms/__renew - local.set $newData - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $newData - local.get $oldData - i32.ne - if - local.get $array - local.get $newData - i32.store - local.get $array - local.get $newData - i32.store offset=4 - local.get $array - local.get $newData - i32.const 0 - call $~lib/rt/itcms/__link - end - local.get $array - local.get $newCapacity - i32.store offset=8 - end - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#unshift (param $this i32) (param $value i32) (result i32) - (local $len i32) - (local $ptr i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.set $ptr - local.get $ptr - i32.const 4 - i32.add - local.get $ptr - local.get $len - i32.const 1 - i32.sub - i32.const 2 - i32.shl - memory.copy - local.get $ptr - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory-page/Arena#constructor (param $this i32) (param $pageCount i32) (result i32) - (local $2 i32) - (local $data i32) - (local $i i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 15 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:free - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:arenaBytes - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory-page/Arena#set:extraPageIndex - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $assembly/memory-page/PAGE_SIZE - local.get $pageCount - i32.mul - call $assembly/memory-page/Arena#set:arenaBytes - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - i32.const 2 - i32.const 16 - i32.const 1856 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory-page/Arena#set:free - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pageCount - call $assembly/memory-page/Arena#set:extraPageIndex - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory-page/Arena#get:arenaBytes - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $data - i32.store offset=12 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $pageCount - i32.lt_s - if - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory-page/Arena#get:free - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - local.get $i - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array.wrap - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory-page/RawPage#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/array/Array#unshift - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/memory/MemoryBuilder#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 24 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $"~lib/map/Map#constructor" - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/MemoryBuilder#set:pages - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - i32.const 128 - call $assembly/memory-page/Arena#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/MemoryBuilder#set:arena - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $"~lib/map/Map#find" (param $this i32) (param $key i32) (param $hashCode i32) (result i32) - (local $entry i32) - (local $taggedNext i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - i32.load - local.set $entry - loop $while-continue|0 - local.get $entry - if - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - local.set $taggedNext - local.get $taggedNext - i32.const 1 - i32.and - i32.eqz - if (result i32) - local.get $entry - call $"~lib/map/MapEntry#get:key" - local.get $key - i32.eq - else - i32.const 0 - end - if - local.get $entry - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $taggedNext - i32.const 1 - i32.const -1 - i32.xor - i32.and - local.set $entry - br $while-continue|0 - end - end - i32.const 0 - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $"~lib/map/Map#has" (param $this i32) (param $key i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $key - local.get $key - call $~lib/util/hash/HASH - call $"~lib/map/Map#find" - i32.const 0 - i32.ne - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/Memory#constructor (param $this i32) (param $arena i32) (param $pages i32) (param $sbrkAddress i32) (result i32) - (local $sbrkPage i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 14 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $arena - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory/Memory#set:arena - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/memory/Memory#set:pages - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $sbrkAddress - call $assembly/memory/Memory#set:sbrkAddress - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 0 - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $sbrkAddress - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $sbrkPage - local.get $sbrkPage - global.get $assembly/memory-page/RESERVED_PAGES - i32.lt_u - if - i32.const 1936 - i32.const 2048 - i32.const 119 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $sbrkPage - call $"~lib/map/Map#has" - if (result i32) - local.get $sbrkPage - else - local.get $sbrkPage - i32.const 1 - i32.sub - end - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/memory/MemoryBuilder#build (param $this i32) (param $sbrkAddress i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - i32.const 0 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MemoryBuilder#get:arena - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MemoryBuilder#get:pages - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $sbrkAddress - call $assembly/memory/Memory#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/MemoryBuilder#build@varargs (param $this i32) (param $sbrkAddress i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - global.get $assembly/memory-page/RESERVED_MEMORY - local.set $sbrkAddress - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $sbrkAddress - call $assembly/memory/MemoryBuilder#build - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $assembly/test/Assert#constructor (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 21 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 1 - call $assembly/test/Assert#set:isOkay - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - i32.const 2 - i32.const 22 - i32.const 2112 - call $~lib/rt/__newArray - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/test/Assert#set:errors - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - ) - (func $~lib/util/string/joinStringArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $4 i32) - (local $estLen i32) - (local $value i32) - (local $i i32) - (local $offset i32) - (local $sepLen i32) - (local $result i32) - (local $i|11 i32) - (local $valueLen i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - end - local.get $lastIndex - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - i32.load - local.tee $4 - i32.store - local.get $4 - if (result i32) - local.get $4 - else - i32.const 4080 - end - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - end - i32.const 0 - local.set $estLen - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $i - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $estLen - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - i32.add - local.set $estLen - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $offset - local.get $separator - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - local.set $sepLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - local.get $sepLen - local.get $lastIndex - i32.mul - i32.add - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=12 - i32.const 0 - local.set $i|11 - loop $for-loop|1 - local.get $i|11 - local.get $lastIndex - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $i|11 - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - local.set $valueLen - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value - local.get $valueLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $valueLen - i32.add - local.set $offset - end - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i|11 - i32.const 1 - i32.add - local.set $i|11 - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $dataStart - local.get $lastIndex - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - local.get $value - i32.const 0 - i32.ne - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value - local.get $value - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=8 - local.get $13 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - memory.copy - end - local.get $result - local.set $13 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $13 - return - ) - (func $~lib/staticarray/StaticArray<~lib/string/String>#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - drop - i32.const 0 - i32.const 1 - i32.lt_s - drop - i32.const 1 - drop - local.get $this - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/staticarray/StaticArray<~lib/string/String>#get:length - local.get $separator - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/util/string/joinStringArray - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/array/Array<~lib/string/String>#push (param $this i32) (param $value i32) (result i32) - (local $oldLen i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array<~lib/string/String>#get:length_ - local.set $oldLen - local.get $oldLen - i32.const 1 - i32.add - local.set $len - local.get $this - local.get $len - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - i32.const 1 - drop - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.get $oldLen - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $len - call $~lib/array/Array<~lib/string/String>#set:length_ - local.get $len - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) - (local $4 i32) - (local $5 i32) - (local $actualDisplay i32) - (local $7 i32) - (local $8 i32) - (local $expectDisplay i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $actual - local.get $expected - i32.ne - if - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 10 - call $~lib/number/I32#toString - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 16 - call $~lib/number/I32#toString - local.tee $5 - i32.store offset=8 - i32.const 2256 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $4 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 2256 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $5 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 2256 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $actualDisplay - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 10 - call $~lib/number/I32#toString - local.tee $7 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 16 - call $~lib/number/I32#toString - local.tee $8 - i32.store offset=24 - i32.const 4112 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $7 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4112 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $8 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4112 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $expectDisplay - i32.store offset=28 - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - call $assembly/test/Assert#get:errors - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $10 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $12 - i32.store offset=44 - i32.const 4272 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 1 - local.get $10 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4272 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 3 - local.get $11 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4272 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 5 - local.get $12 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4272 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i64) (param $expected i64) (param $msg i32) - (local $4 i32) - (local $5 i32) - (local $actualDisplay i32) - (local $7 i32) - (local $8 i32) - (local $expectDisplay i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $actual - local.get $expected - i64.ne - if - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 10 - call $~lib/number/U64#toString - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 16 - call $~lib/number/U64#toString - local.tee $5 - i32.store offset=8 - i32.const 4320 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $4 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4320 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $5 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4320 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $actualDisplay - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 10 - call $~lib/number/U64#toString - local.tee $7 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 16 - call $~lib/number/U64#toString - local.tee $8 - i32.store offset=24 - i32.const 4368 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $7 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4368 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $8 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4368 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $expectDisplay - i32.store offset=28 - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - call $assembly/test/Assert#get:errors - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $10 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $12 - i32.store offset=44 - i32.const 4416 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 1 - local.get $10 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4416 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 3 - local.get $11 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4416 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 5 - local.get $12 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 4416 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit.test~anonymous|0 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281470681747729 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/count_set_bits_64 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 2 - i64.const 8 - i64.mul - i64.const 4 - i64.add - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/test/Test#constructor (param $this i32) (param $name i32) (param $ptr i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 20 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $name - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/test/Test#set:name - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $ptr - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/test/Test#set:ptr - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/test/test (param $name i32) (param $ptr i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 0 - local.get $name - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $ptr - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/test/Test#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|1 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281470681747729 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/count_set_bits_32 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 4 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|2 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281406257234193 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/leading_zero_bits_64 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 16 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|3 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281470681747729 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/leading_zero_bits_32 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 19 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|4 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281406257233920 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/trailing_zero_bits_64 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 36 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|5 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281406257233920 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/trailing_zero_bits_32 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 32 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|6 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/sign_extend_8 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -17 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|7 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/sign_extend_16 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -16657 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/bit.test~anonymous|8 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/zero_extend_16 - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 48879 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i64) (param $expected i64) (param $msg i32) - (local $4 i32) - (local $5 i32) - (local $actualDisplay i32) - (local $7 i32) - (local $8 i32) - (local $expectDisplay i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $actual - local.get $expected - i64.ne - if - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 10 - call $~lib/number/I64#toString - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 16 - call $~lib/number/I64#toString - local.tee $5 - i32.store offset=8 - i32.const 5264 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $4 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5264 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $5 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5264 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $actualDisplay - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 10 - call $~lib/number/I64#toString - local.tee $7 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 16 - call $~lib/number/I64#toString - local.tee $8 - i32.store offset=24 - i32.const 5312 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $7 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5312 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $8 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5312 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $expectDisplay - i32.store offset=28 - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - call $assembly/test/Assert#get:errors - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $10 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $12 - i32.store offset=44 - i32.const 5360 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 1 - local.get $10 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5360 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 3 - local.get $11 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5360 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 5 - local.get $12 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 5360 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit.test~anonymous|9 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $res i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 15 - call $assembly/arguments/Args#set:b - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 281409993162479 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/bit/reverse_bytes - i32.load - call_indirect (type $1) - local.tee $res - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i64.const 15 - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1171307680032161792 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 1888 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/bit.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - call $start:assembly/arguments - call $start:assembly/memory - global.get $~lib/memory/__stack_pointer - i32.const 10 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 1792 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4464 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 4496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4560 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 4592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4656 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - i32.const 4688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4752 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - i32.const 4784 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4848 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 5 - i32.const 4880 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 4944 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 6 - i32.const 4976 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 5024 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 7 - i32.const 5056 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 5104 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 8 - i32.const 5136 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 5184 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 9 - i32.const 5216 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 5408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/bit.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/instructions/outcome/staticJump (param $offset i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.StaticJump - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $offset - call $assembly/instructions/outcome/OutcomeData#set:staticJump - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/branch~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.eq - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.ne - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.lt_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.le_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.ge_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $b - i64.gt_u - if - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/branch~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.lt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.le_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.ge_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.gt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.eq - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ne - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_u - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ge_u - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/branch~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.ge_s - if - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) - (local $4 i32) - (local $5 i32) - (local $actualDisplay i32) - (local $7 i32) - (local $8 i32) - (local $expectDisplay i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $actual - local.get $expected - i32.ne - if - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 10 - call $~lib/number/U32#toString - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 16 - call $~lib/number/U32#toString - local.tee $5 - i32.store offset=8 - i32.const 6048 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $4 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6048 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $5 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6048 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $actualDisplay - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 10 - call $~lib/number/U32#toString - local.tee $7 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 16 - call $~lib/number/U32#toString - local.tee $8 - i32.store offset=24 - i32.const 6096 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $7 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6096 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $8 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6096 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $expectDisplay - i32.store offset=28 - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - call $assembly/test/Assert#get:errors - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $10 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $12 - i32.store offset=44 - i32.const 6144 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 1 - local.get $10 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6144 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 3 - local.get $11 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6144 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 5 - local.get $12 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 6144 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/branch.test~anonymous|0 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 254 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const -559038737 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 254 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/branch/branch_eq_imm - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.StaticJump - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:staticJump - i32.const -559038737 - i32.const 6000 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/branch.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 1 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 5952 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 6192 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/branch.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/logic~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.and - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1 - i64.xor - i64.or - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.xor - i64.const -1 - i64.xor - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/logic.test~anonymous|0 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 3 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 15 - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 263882790666241 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/logic/and_inv - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 263882790666240 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/logic.test~anonymous|1 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 3 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 15 - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 263882790666241 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/logic/or_inv - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -15 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/logic.test~anonymous|2 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 3 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 15 - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 263882790666240 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/logic/xnor - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -263882790666256 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/logic.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 3 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 6512 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 6560 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 6592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 6624 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 6656 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 6688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/logic.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/math~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $c i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $c - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $c - i64.add - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.mul - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.const 4294967296 - i64.or - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $sum i64) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - local.set $sum - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $sum - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/math~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i32.add - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 2 - i64.const 32 - call $~lib/math/ipow64 - i64.add - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - i64.extend_i32_u - i64.sub - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.mul - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i32.div_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i32.MIN_VALUE - i64.extend_i32_s - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i32) - (local $b i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i32.rem_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i32) - (local $a i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $a - local.get $a - i32.const 0 - i32.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - i64.extend_i32_s - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i32.const -1 - i32.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i32.MIN_VALUE - i32.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - i64.extend_i32_s - local.get $a - i64.extend_i32_s - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.sub - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.mul - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.div_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - global.get $~lib/builtins/u64.MAX_VALUE - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i64.MIN_VALUE - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.div_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|18 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.rem_u - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|19 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $b i64) - (local $a i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $a - i64.const 0 - i64.eq - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - call $~lib/staticarray/StaticArray#__set - else - local.get $a - i64.const -1 - i64.eq - if (result i32) - local.get $b - global.get $~lib/builtins/i64.MIN_VALUE - i64.eq - else - i32.const 0 - end - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - call $~lib/staticarray/StaticArray#__set - else - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $b - local.get $a - i64.rem_s - call $~lib/staticarray/StaticArray#__set - end - end - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|20 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperSigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|21 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperUnsigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|22 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/mulUpperSignedUnsigned - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/math~anonymous|23 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.lt_s - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|24 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.lt_u - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|25 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.gt_s - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math~anonymous|26 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $a i64) - (local $b i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $a - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $b - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $a - local.get $b - i64.gt_u - if (result i64) - local.get $b - else - local.get $a - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/math.test~anonymous|0 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 3 - i32.const 0 - call $assembly/arguments/Args.from - local.tee $args - i32.store - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=4 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/math/max - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 2 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/math.test~anonymous|1 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 3 - i32.const 0 - call $assembly/arguments/Args.from - local.tee $args - i32.store - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=4 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/math/max_u - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/math.test~anonymous|2 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 3 - i32.const 0 - call $assembly/arguments/Args.from - local.tee $args - i32.store - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=4 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/math/min - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/math.test~anonymous|3 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 3 - i32.const 0 - call $assembly/arguments/Args.from - local.tee $args - i32.store - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=4 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 0 - i64.const 2 - i64.const 63 - call $~lib/math/ipow64 - i64.sub - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/math/min_u - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 2 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/math.test~anonymous|4 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 1 - i32.const 3 - i32.const 0 - call $assembly/arguments/Args.from - local.tee $args - i32.store - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=4 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - i64.const 64 - call $~lib/math/ipow64 - i64.const 1 - i64.sub - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 2 - i64.const 64 - call $~lib/math/ipow64 - i64.const 1 - i64.sub - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/math/add_32 - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -2 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/math.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 5 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 7584 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 7616 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 7648 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 7680 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 7712 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 7744 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - i32.const 7776 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 7808 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - i32.const 7840 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 7872 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/math.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/rot~anonymous|0 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|1 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|2 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|3 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|4 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_l - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|5 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_l_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|6 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/rot/math.rot_r - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot~anonymous|7 (param $args i32) (param $regs i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.get $regs - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/rot/math.rot_r_32 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/rot.test~anonymous|0 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 8 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/rot/rot_r_64_imm - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1224979098630181442 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/rot.test~anonymous|1 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const -559038737 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 8 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/rot/rot_r_64_imm_alt - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1152921504609030722 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/rot.test~anonymous|2 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 8 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 8 - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/rot/rot_l_64 - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 956397711104 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/rot.test~anonymous|3 (param $$0 i32) (result i32) - (local $args i32) - (local $regs i32) - (local $memo i32) - (local $ret i32) - (local $assert i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/arguments/Args#constructor - local.tee $args - i32.store - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - call $assembly/arguments/Args#set:a - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 1 - call $assembly/arguments/Args#set:b - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 8 - call $assembly/arguments/Args#set:c - global.get $~lib/memory/__stack_pointer - call $assembly/registers/newRegisters - local.tee $regs - i32.store offset=8 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 8 - call $~lib/staticarray/StaticArray#__set - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - i64.const 3735928559 - call $~lib/staticarray/StaticArray#__set - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $memo - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - local.get $memo - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - i32.const 3 - global.set $~argumentsLength - global.get $assembly/instructions/rot/rot_l_32 - i32.load - call_indirect (type $1) - local.tee $ret - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=28 - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $ret - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - call $assembly/instructions/outcome/OutcomeData#get:outcome - global.get $assembly/instructions/outcome/Outcome.Ok - i32.const 2144 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=4 - local.get $6 - local.get $regs - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=20 - local.get $6 - local.get $args - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=32 - local.get $6 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const -1379995682 - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $start:assembly/instructions/rot.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 8160 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 8208 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 8240 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 8304 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 8336 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 8384 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - i32.const 8416 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 8464 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/rot.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Chunks#constructor (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 30 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:fault - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:first - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#set:second - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory/Chunks#constructor@varargs (param $this i32) (param $fault i32) (param $first i32) (param $second i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $first - i32.store - end - global.get $~lib/memory/__stack_pointer - global.get $assembly/memory/EMPTY_UINT8ARRAY - local.tee $second - i32.store offset=4 - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - local.get $first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - local.get $second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - local.get $4 - call $assembly/memory/Chunks#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory/PageData#constructor (param $this i32) (param $fault i32) (param $page i32) (param $relativeAddress i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 31 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/PageData#set:fault - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $page - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/PageData#set:page - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $relativeAddress - call $assembly/memory/PageData#set:relativeAddress - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory/fault (param $address i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isFault - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $address - call $assembly/memory/MaybePageFault#set:fault - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $"~lib/map/Map#get" (param $this i32) (param $key i32) (result i32) - (local $entry i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $key - local.get $key - call $~lib/util/hash/HASH - call $"~lib/map/Map#find" - local.set $entry - local.get $entry - i32.eqz - if - i32.const 8624 - i32.const 8688 - i32.const 105 - i32.const 17 - call $~lib/builtins/abort - unreachable - end - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory-page/Page#can (param $this i32) (param $access i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/Page#get:access - global.get $assembly/memory-page/Access.Write - i32.eq - if (result i32) - i32.const 1 - else - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/Page#get:access - local.get $access - i32.eq - end - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/Memory#getPage (param $this i32) (param $access i32) (param $address i32) (result i32) - (local $pageIdx i32) - (local $relAddress i32) - (local $pageStart i32) - (local $page i32) - (local $f i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $address - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $pageIdx - local.get $address - global.get $assembly/memory-page/PAGE_SIZE - i32.rem_u - local.set $relAddress - local.get $pageIdx - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - local.set $pageStart - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/memory/Memory#get:pages - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $pageIdx - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.get $pageStart - call $assembly/memory/fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory/EMPTY_PAGE - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/memory/Memory#get:pages - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $pageIdx - call $"~lib/map/Map#get" - local.tee $page - i32.store offset=8 - local.get $page - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $access - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $pageStart - call $assembly/memory/fault - local.tee $f - i32.store offset=12 - local.get $f - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isAccess - i32.const 0 - local.get $f - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory/EMPTY_PAGE - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $page - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $relAddress - call $assembly/memory/PageData#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/typedarray/Uint8Array#fill (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $value - local.get $start - local.get $end - call $~lib/util/bytes/FILL - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/typedarray/Uint8Array#fill@varargs (param $this i32) (param $value i32) (param $start i32) (param $end i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $value - local.get $start - local.get $end - call $~lib/typedarray/Uint8Array#fill - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/memory-page/RawPage#get:data (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:page - i32.const 0 - i32.eq - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - i32.const 0 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#fill@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory-page/RawPage#set:page - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/memory-page/RawPage#get:page - local.tee $1 - i32.store offset=12 - local.get $1 - if (result i32) - local.get $1 - else - i32.const 8736 - i32.const 8864 - i32.const 46 - i32.const 12 - call $~lib/builtins/abort - unreachable - end - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/memory/Memory#getChunks (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) - (local $pageData i32) - (local $page i32) - (local $relativeAddress i32) - (local $endAddress i32) - (local $needSecondPage i32) - (local $first i32) - (local $secondPageIdx i32) - (local $secondPageStart i32) - (local $secondPage i32) - (local $f i32) - (local $firstChunk i32) - (local $secondChunk i32) - (local $16 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - local.get $bytes - i32.const 255 - i32.and - i32.const 0 - i32.eq - if - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $access - local.get $address - call $assembly/memory/Memory#getPage - local.tee $pageData - i32.store offset=4 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/PageData#get:fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/MaybePageFault#get:isFault - if - i32.const 0 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/PageData#get:fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/PageData#get:page - local.tee $page - i32.store offset=12 - local.get $pageData - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - call $assembly/memory/PageData#get:relativeAddress - local.set $relativeAddress - local.get $relativeAddress - local.get $bytes - i32.const 255 - i32.and - i32.add - local.set $endAddress - local.get $endAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.gt_u - local.set $needSecondPage - local.get $needSecondPage - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $page - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $relativeAddress - local.get $endAddress - call $~lib/typedarray/Uint8Array#subarray - local.tee $first - i32.store offset=20 - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $first - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - i32.const 2 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - local.get $address - local.get $bytes - i32.const 255 - i32.and - i32.add - i64.extend_i32_u - global.get $assembly/memory/MEMORY_SIZE - i64.rem_s - i32.wrap_i64 - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $secondPageIdx - local.get $secondPageIdx - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - local.set $secondPageStart - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/Memory#get:pages - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $secondPageIdx - call $"~lib/map/Map#has" - i32.eqz - if - i32.const 0 - local.get $secondPageStart - call $assembly/memory/fault - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory/Memory#get:pages - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $secondPageIdx - call $"~lib/map/Map#get" - local.tee $secondPage - i32.store offset=24 - local.get $secondPage - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $access - call $assembly/memory-page/Page#can - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $secondPageStart - call $assembly/memory/fault - local.tee $f - i32.store offset=28 - local.get $f - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isAccess - i32.const 0 - local.get $f - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/Chunks#constructor@varargs - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - end - global.get $~lib/memory/__stack_pointer - local.get $page - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $relativeAddress - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $firstChunk - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $secondPage - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory-page/Page#get:raw - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - call $assembly/memory-page/RawPage#get:data - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - i32.const 0 - local.get $relativeAddress - local.get $bytes - i32.const 255 - i32.and - i32.add - global.get $assembly/memory-page/PAGE_SIZE - i32.sub - call $~lib/typedarray/Uint8Array#subarray - local.tee $secondChunk - i32.store offset=36 - i32.const 0 - global.get $assembly/memory/NO_PAGE_FAULT - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store - local.get $16 - local.get $firstChunk - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=8 - local.get $16 - local.get $secondChunk - local.set $16 - global.get $~lib/memory/__stack_pointer - local.get $16 - i32.store offset=16 - local.get $16 - call $assembly/memory/Chunks#constructor - local.set $16 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $16 - return - ) - (func $assembly/memory/ChunkBytes#constructor (param $this i32) (param $fault i32) (param $bytes i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 28 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $fault - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory/ChunkBytes#set:fault - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $bytes - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/memory/ChunkBytes#set:bytes - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/ChunkBytes#constructor@varargs (param $this i32) (param $fault i32) (param $bytes i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - block $1of1 - block $0of1 - block $outOfRange - global.get $~argumentsLength - i32.const 1 - i32.sub - br_table $0of1 $1of1 $outOfRange - end - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/staticarray/StaticArray#constructor - local.tee $bytes - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $fault - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - local.get $bytes - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - call $assembly/memory/ChunkBytes#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/getBytes (param $bytes i32) (param $first i32) (param $second i32) (result i32) - (local $res i32) - (local $len i32) - (local $i i32) - (local $i|6 i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $bytes - i32.const 255 - i32.and - call $~lib/staticarray/StaticArray#constructor - local.tee $res - i32.store - local.get $first - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $i - local.get $first - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|6 - loop $for-loop|1 - local.get $i|6 - local.get $second - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $len - local.get $i|6 - i32.add - local.get $second - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - local.get $i|6 - call $~lib/typedarray/Uint8Array#__get - call $~lib/staticarray/StaticArray#__set - local.get $i|6 - i32.const 1 - i32.add - local.set $i|6 - br $for-loop|1 - end - end - local.get $res - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $assembly/memory/Memory#getBytes (param $this i32) (param $access i32) (param $address i32) (param $bytes i32) (result i32) - (local $res i32) - (local $data i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $access - local.get $address - local.get $bytes - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $assembly/memory/MaybePageFault#get:isFault - if - i32.const 0 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/ChunkBytes#constructor@varargs - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - global.get $~lib/memory/__stack_pointer - local.get $bytes - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:first - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:second - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/getBytes - local.tee $data - i32.store offset=16 - i32.const 0 - local.get $res - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=12 - local.get $6 - call $assembly/memory/Chunks#get:fault - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $data - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store offset=8 - local.get $6 - call $assembly/memory/ChunkBytes#constructor - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/memory/Result#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.const 27 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/object/Object#constructor - local.tee $this - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i64.const 0 - call $assembly/memory/Result#set:ok - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 0 - call $assembly/memory/MaybePageFault#constructor - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/memory/Result#set:fault - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/memory/Memory#getI8 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - call $assembly/instructions/utils/u8SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU64 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 8 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 8 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 16 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 24 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 4 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 32 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 5 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 40 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 6 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 48 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 7 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - i64.const 56 - i64.shl - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/test/Assert#isEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) - (local $4 i32) - (local $5 i32) - (local $actualDisplay i32) - (local $7 i32) - (local $8 i32) - (local $expectDisplay i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $actual - i32.const 0 - i32.ne - local.get $expected - i32.const 0 - i32.ne - i32.ne - if - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 0 - call $~lib/number/Bool#toString - local.tee $4 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $actual - i32.const 16 - call $~lib/number/Bool#toString - local.tee $5 - i32.store offset=8 - i32.const 8992 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $4 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 8992 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $5 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 8992 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $actualDisplay - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 0 - call $~lib/number/Bool#toString - local.tee $7 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expected - i32.const 16 - call $~lib/number/Bool#toString - local.tee $8 - i32.store offset=24 - i32.const 9104 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 0 - local.get $7 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 9104 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 2 - local.get $8 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 9104 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.tee $expectDisplay - i32.store offset=28 - local.get $this - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - call $assembly/test/Assert#get:errors - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store - local.get $13 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $10 - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $11 - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $12 - i32.store offset=44 - i32.const 9152 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 1 - local.get $10 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 9152 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 3 - local.get $11 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 9152 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 5 - local.get $12 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 9152 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=32 - local.get $13 - i32.const 4080 - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=48 - local.get $13 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $13 - global.get $~lib/memory/__stack_pointer - local.get $13 - i32.store offset=12 - local.get $13 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/memory.test~anonymous|0 (param $$0 i32) (result i32) - (local $mem i32) - (local $a i32) - (local $b i32) - (local $assert i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $mem - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $assembly/memory/Memory#getI8 - local.tee $a - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - global.get $assembly/memory-page/RESERVED_MEMORY - i32.const 1 - i32.sub - call $assembly/memory/Memory#getU64 - local.tee $b - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=16 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $a - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 1 - i32.const 8944 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $a - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9200 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $a - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:fault - i32.const 0 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $b - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 1 - i32.const 9248 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $b - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9296 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $b - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/memory/MaybePageFault#get:fault - i32.const 61440 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/string/String#concat (param $this i32) (param $other i32) (result i32) - (local $thisSize i32) - (local $otherSize i32) - (local $outSize i32) - (local $out i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $thisSize - local.get $other - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - call $~lib/string/String#get:length - i32.const 1 - i32.shl - local.set $otherSize - local.get $thisSize - local.get $otherSize - i32.add - local.set $outSize - local.get $outSize - i32.const 0 - i32.eq - if - i32.const 4080 - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - end - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $out - local.get $this - local.get $thisSize - memory.copy - local.get $out - local.get $thisSize - i32.add - local.get $other - local.get $otherSize - memory.copy - local.get $out - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#pop (param $this i32) (result i32) - (local $len i32) - (local $val i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - local.set $len - local.get $len - i32.const 1 - i32.lt_s - if - i32.const 9584 - i32.const 1888 - i32.const 271 - i32.const 18 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $len - i32.const 1 - i32.sub - local.tee $len - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $val - i32.store offset=4 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $len - call $~lib/array/Array#set:length_ - local.get $val - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/console/console.log (param $message i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $message - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/bindings/dom/console.log - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory-page/Arena#acquire (param $this i32) (result i32) - (local $allocatedMemory i32) - (local $data i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:free - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - i32.const 0 - i32.gt_s - if - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:free - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#pop - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.set $allocatedMemory - local.get $allocatedMemory - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/Arena#get:arenaBytes - i32.eq - if - i32.const 9632 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/console/console.log - end - global.get $~lib/memory/__stack_pointer - local.get $allocatedMemory - global.get $assembly/memory-page/ALLOCATE_EAGERLY - i32.lt_u - if (result i32) - i32.const 0 - global.get $assembly/memory-page/PAGE_SIZE - call $~lib/typedarray/Uint8Array#constructor - else - i32.const 0 - end - local.tee $data - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - i32.const 1 - i32.add - call $assembly/memory-page/Arena#set:extraPageIndex - i32.const 0 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/memory-page/Arena#get:extraPageIndex - local.get $data - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/memory-page/RawPage#constructor - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $"~lib/map/Map#rehash" (param $this i32) (param $newBucketsMask i32) - (local $newBucketsCapacity i32) - (local $newBuckets i32) - (local $newEntriesCapacity i32) - (local $newEntries i32) - (local $oldPtr i32) - (local $oldEnd i32) - (local $newPtr i32) - (local $oldEntry i32) - (local $newEntry i32) - (local $oldEntryKey i32) - (local $newBucketIndex i32) - (local $newBucketPtrBase i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $newBucketsMask - i32.const 1 - i32.add - local.set $newBucketsCapacity - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newBucketsCapacity - i32.const 4 - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newBuckets - i32.store - local.get $newBucketsCapacity - i32.const 8 - i32.mul - i32.const 3 - i32.div_s - local.set $newEntriesCapacity - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $newEntriesCapacity - block $"~lib/map/ENTRY_SIZE|inlined.1" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.1" - end - i32.mul - call $~lib/arraybuffer/ArrayBuffer#constructor - local.tee $newEntries - i32.store offset=4 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entries" - local.set $oldPtr - local.get $oldPtr - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.2" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.2" - end - i32.mul - i32.add - local.set $oldEnd - local.get $newEntries - local.set $newPtr - loop $while-continue|0 - local.get $oldPtr - local.get $oldEnd - i32.ne - if - local.get $oldPtr - local.set $oldEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - local.get $newPtr - local.set $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:key" - local.set $oldEntryKey - local.get $newEntry - local.get $oldEntryKey - call $"~lib/map/MapEntry#set:key" - local.get $newEntry - local.get $oldEntry - call $"~lib/map/MapEntry#get:value" - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - call $"~lib/map/MapEntry#set:value" - local.get $oldEntryKey - call $~lib/util/hash/HASH - local.get $newBucketsMask - i32.and - local.set $newBucketIndex - local.get $newBuckets - local.get $newBucketIndex - i32.const 4 - i32.mul - i32.add - local.set $newBucketPtrBase - local.get $newEntry - local.get $newBucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $newBucketPtrBase - local.get $newPtr - i32.store - local.get $newPtr - block $"~lib/map/ENTRY_SIZE|inlined.3" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.3" - end - i32.add - local.set $newPtr - end - local.get $oldPtr - block $"~lib/map/ENTRY_SIZE|inlined.4" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.4" - end - i32.add - local.set $oldPtr - br $while-continue|0 - end - end - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBuckets - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:buckets" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newBucketsMask - call $"~lib/map/Map#set:bucketsMask" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntries - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#set:entries" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $newEntriesCapacity - call $"~lib/map/Map#set:entriesCapacity" - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=8 - local.get $14 - local.get $this - local.set $14 - global.get $~lib/memory/__stack_pointer - local.get $14 - i32.store offset=12 - local.get $14 - call $"~lib/map/Map#get:entriesCount" - call $"~lib/map/Map#set:entriesOffset" - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#set" (param $this i32) (param $key i32) (param $value i32) (result i32) - (local $hashCode i32) - (local $entry i32) - (local $entries i32) - (local $6 i32) - (local $bucketPtrBase i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $key - call $~lib/util/hash/HASH - local.set $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $key - local.get $hashCode - call $"~lib/map/Map#find" - local.set $entry - local.get $entry - if - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.eq - if - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCapacity" - i32.const 3 - i32.mul - i32.const 4 - i32.div_s - i32.lt_s - if (result i32) - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - else - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.const 1 - i32.shl - i32.const 1 - i32.or - end - call $"~lib/map/Map#rehash" - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:entries" - local.tee $entries - i32.store offset=8 - local.get $entries - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesOffset" - local.tee $6 - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesOffset" - local.get $6 - block $"~lib/map/ENTRY_SIZE|inlined.5" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.5" - end - i32.mul - i32.add - local.set $entry - local.get $entry - local.get $key - call $"~lib/map/MapEntry#set:key" - i32.const 0 - drop - local.get $entry - local.get $value - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/MapEntry#set:value" - i32.const 1 - drop - local.get $this - local.get $value - i32.const 1 - call $~lib/rt/itcms/__link - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $"~lib/map/Map#get:entriesCount" - i32.const 1 - i32.add - call $"~lib/map/Map#set:entriesCount" - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:buckets" - local.get $hashCode - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $"~lib/map/Map#get:bucketsMask" - i32.and - i32.const 4 - i32.mul - i32.add - local.set $bucketPtrBase - local.get $entry - local.get $bucketPtrBase - i32.load - call $"~lib/map/MapEntry#set:taggedNext" - local.get $bucketPtrBase - local.get $entry - i32.store - end - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/memory/MemoryBuilder#getOrCreatePageForAddress (param $this i32) (param $access i32) (param $address i32) (result i32) - (local $pageIdx i32) - (local $page i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $address - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shr_u - local.set $pageIdx - local.get $pageIdx - global.get $assembly/memory-page/RESERVED_PAGES - i32.lt_u - if - i32.const 9488 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - i32.const 10 - call $~lib/number/U32#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/string/String#concat - i32.const 2048 - i32.const 93 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/MemoryBuilder#get:pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - call $"~lib/map/Map#has" - i32.eqz - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/MemoryBuilder#get:arena - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=8 - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/MemoryBuilder#get:pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - i32.const 0 - local.get $access - local.get $page - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory-page/Page#constructor - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $"~lib/map/Map#set" - drop - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/MemoryBuilder#get:pages - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $pageIdx - call $"~lib/map/Map#get" - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.set $sourceStart - i32.const 0 - i32.eqz - drop - local.get $targetStart - local.get $sourceStart - local.get $sourceLen - i32.const 0 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MemoryBuilder#setData (param $this i32) (param $access i32) (param $address i32) (param $data i32) (result i32) - (local $currentAddress i32) - (local $currentData i32) - (local $page i32) - (local $relAddress i32) - (local $spaceInPage i32) - (local $end i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $address - local.set $currentAddress - global.get $~lib/memory/__stack_pointer - local.get $data - local.tee $currentData - i32.store - loop $while-continue|0 - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.const 0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $access - local.get $currentAddress - call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress - local.tee $page - i32.store offset=8 - local.get $currentAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.rem_u - local.set $relAddress - global.get $assembly/memory-page/PAGE_SIZE - local.get $relAddress - i32.sub - local.set $spaceInPage - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - local.get $spaceInPage - i32.lt_u - if (result i32) - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - else - local.get $spaceInPage - end - local.set $end - local.get $page - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $10 - call $assembly/memory-page/Page#get:raw - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - call $assembly/memory-page/RawPage#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - i32.const 0 - local.get $end - call $~lib/typedarray/Uint8Array#subarray - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - local.get $relAddress - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $currentAddress - local.get $end - i32.add - local.set $currentAddress - global.get $~lib/memory/__stack_pointer - local.get $currentData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $end - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.tee $currentData - i32.store - br $while-continue|0 - end - end - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $assembly/memory/Memory#getU8 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 1 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/typedarray/Uint8Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/arraybuffer/ArrayBufferView#get:byteLength - i32.ge_u - if - i32.const 480 - i32.const 720 - i32.const 178 - i32.const 45 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $index - i32.add - local.get $value - i32.store8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#setU8 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 1 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/memory.test~anonymous|1 (param $$0 i32) (result i32) - (local $builder i32) - (local $mem i32) - (local $a i32) - (local $b i32) - (local $c i32) - (local $d i32) - (local $assert i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store - local.get $builder - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $assembly/memory-page/Access.Read - global.get $assembly/memory-page/RESERVED_MEMORY - i32.const 0 - i32.const 10 - call $~lib/typedarray/Uint8Array#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/MemoryBuilder#setData - drop - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $mem - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $assembly/memory-page/RESERVED_MEMORY - call $assembly/memory/Memory#getU64 - local.tee $a - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $assembly/memory-page/RESERVED_PAGES - i32.const 1 - i32.add - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - call $assembly/memory/Memory#getU8 - local.tee $b - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $assembly/memory-page/RESERVED_MEMORY - i32.const 12 - call $assembly/memory/Memory#setU8 - local.tee $c - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $assembly/memory-page/RESERVED_MEMORY - call $assembly/memory/Memory#getU8 - local.tee $d - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=32 - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $a - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=40 - local.get $8 - call $assembly/memory/Result#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 8944 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $a - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=40 - local.get $8 - call $assembly/memory/Result#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9200 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $a - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/Result#get:ok - i64.const 0 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $b - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=40 - local.get $8 - call $assembly/memory/Result#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 1 - i32.const 9248 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $b - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=40 - local.get $8 - call $assembly/memory/Result#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9296 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $b - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=40 - local.get $8 - call $assembly/memory/Result#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:fault - i32.const 69632 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 1 - i32.const 9728 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 1 - i32.const 9776 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $c - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/MaybePageFault#get:fault - i32.const 65536 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $d - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=36 - local.get $8 - call $assembly/memory/Result#get:ok - i64.const 0 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $i i32) - (local $ptr i32) - (local $value i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/array/Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/array/Array#get:dataStart - local.set $sourceStart - i32.const 0 - i32.const 2 - i32.eq - drop - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $sourceLen - i32.lt_s - if - local.get $targetStart - local.get $i - i32.const 0 - i32.shl - i32.add - local.set $ptr - local.get $sourceStart - local.get $i - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - i32.const 0 - drop - local.get $ptr - local.get $value - i32.store8 - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/Memory#bytesWrite (param $this i32) (param $address i32) (param $source i32) (result i32) - (local $nextAddress i32) - (local $sourceIndex i32) - (local $bytesLeft i32) - (local $pageData i32) - (local $relAddress i32) - (local $bytesToWrite i32) - (local $sourceData i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - local.get $address - local.set $nextAddress - i32.const 0 - local.set $sourceIndex - loop $while-continue|0 - local.get $sourceIndex - local.get $source - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $source - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - local.get $sourceIndex - i32.sub - local.set $bytesLeft - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - global.get $assembly/memory-page/Access.Write - local.get $nextAddress - call $assembly/memory/Memory#getPage - local.tee $pageData - i32.store offset=4 - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/PageData#get:fault - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:fault - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - end - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:relativeAddress - local.set $relAddress - local.get $relAddress - local.get $bytesLeft - i32.add - global.get $assembly/memory-page/PAGE_SIZE - i32.lt_u - if (result i32) - local.get $bytesLeft - else - global.get $assembly/memory-page/PAGE_SIZE - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:relativeAddress - i32.sub - end - local.set $bytesToWrite - global.get $~lib/memory/__stack_pointer - local.get $source - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $sourceIndex - local.get $sourceIndex - local.get $bytesToWrite - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $sourceData - i32.store offset=12 - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=24 - local.get $10 - call $assembly/memory/PageData#get:page - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=20 - local.get $10 - call $assembly/memory-page/Page#get:raw - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - call $assembly/memory-page/RawPage#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $sourceData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - local.get $relAddress - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $sourceIndex - local.get $bytesToWrite - i32.add - local.set $sourceIndex - local.get $nextAddress - local.get $bytesToWrite - i32.add - local.set $nextAddress - br $while-continue|0 - end - end - global.get $assembly/memory/NO_PAGE_FAULT - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $assembly/memory/Memory#bytesRead (param $this i32) (param $address i32) (param $destination i32) (result i32) - (local $nextAddress i32) - (local $destinationIndex i32) - (local $bytesLeft i32) - (local $pageData i32) - (local $relAddress i32) - (local $bytesToRead i32) - (local $source i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - local.get $address - local.set $nextAddress - i32.const 0 - local.set $destinationIndex - loop $while-continue|0 - local.get $destinationIndex - local.get $destination - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $destination - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - local.get $destinationIndex - i32.sub - local.set $bytesLeft - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - global.get $assembly/memory-page/Access.Read - local.get $nextAddress - call $assembly/memory/Memory#getPage - local.tee $pageData - i32.store offset=4 - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/PageData#get:fault - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:fault - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - end - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:relativeAddress - local.set $relAddress - local.get $relAddress - local.get $bytesLeft - i32.add - global.get $assembly/memory-page/PAGE_SIZE - i32.lt_u - if (result i32) - local.get $bytesLeft - else - global.get $assembly/memory-page/PAGE_SIZE - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - call $assembly/memory/PageData#get:relativeAddress - i32.sub - end - local.set $bytesToRead - global.get $~lib/memory/__stack_pointer - local.get $pageData - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=16 - local.get $10 - call $assembly/memory/PageData#get:page - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=12 - local.get $10 - call $assembly/memory-page/Page#get:raw - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory-page/RawPage#get:data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $relAddress - local.get $relAddress - local.get $bytesToRead - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $source - i32.store offset=20 - local.get $destination - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store - local.get $10 - local.get $source - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - local.get $destinationIndex - call $~lib/typedarray/Uint8Array#set<~lib/typedarray/Uint8Array> - local.get $destinationIndex - local.get $bytesToRead - i32.add - local.set $destinationIndex - local.get $nextAddress - local.get $bytesToRead - i32.add - local.set $nextAddress - br $while-continue|0 - end - end - global.get $assembly/memory/NO_PAGE_FAULT - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $~lib/string/String#substring (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $len i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $finalStart i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $finalEnd i32) - (local $14 i32) - (local $15 i32) - (local $fromPos i32) - (local $17 i32) - (local $18 i32) - (local $toPos i32) - (local $size i32) - (local $out i32) - (local $22 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $22 - global.get $~lib/memory/__stack_pointer - local.get $22 - i32.store - local.get $22 - call $~lib/string/String#get:length - local.set $len - local.get $start - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - local.tee $6 - local.get $len - local.tee $7 - local.get $6 - local.get $7 - i32.lt_s - select - local.set $finalStart - local.get $end - local.tee $9 - i32.const 0 - local.tee $10 - local.get $9 - local.get $10 - i32.gt_s - select - local.tee $11 - local.get $len - local.tee $12 - local.get $11 - local.get $12 - i32.lt_s - select - local.set $finalEnd - local.get $finalStart - local.tee $14 - local.get $finalEnd - local.tee $15 - local.get $14 - local.get $15 - i32.lt_s - select - i32.const 1 - i32.shl - local.set $fromPos - local.get $finalStart - local.tee $17 - local.get $finalEnd - local.tee $18 - local.get $17 - local.get $18 - i32.gt_s - select - i32.const 1 - i32.shl - local.set $toPos - local.get $toPos - local.get $fromPos - i32.sub - local.set $size - local.get $size - i32.eqz - if - i32.const 4080 - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - end - local.get $fromPos - i32.eqz - if (result i32) - local.get $toPos - local.get $len - i32.const 1 - i32.shl - i32.eq - else - i32.const 0 - end - if - local.get $this - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - end - global.get $~lib/memory/__stack_pointer - local.get $size - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store offset=4 - local.get $out - local.get $this - local.get $fromPos - i32.add - local.get $size - memory.copy - local.get $out - local.set $22 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $22 - return - ) - (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $value i32) - (local $sepLen i32) - (local $estLen i32) - (local $result i32) - (local $offset i32) - (local $value|9 i32) - (local $i i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 4080 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $lastIndex - i32.eqz - if - local.get $dataStart - i32.load8_u - local.set $value - i32.const 0 - drop - i32.const 1 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 10 - call $~lib/util/number/utoa32 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $separator - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - local.set $sepLen - i32.const 10 - local.get $sepLen - i32.add - local.get $lastIndex - i32.mul - i32.const 10 - i32.add - local.set $estLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=4 - i32.const 0 - local.set $offset - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $lastIndex - i32.lt_s - if - local.get $dataStart - local.get $i - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $dataStart - local.get $lastIndex - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $estLen - local.get $offset - i32.gt_s - if - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.const 0 - local.get $offset - call $~lib/string/String#substring - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/typedarray/Uint8Array#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/typedarray/Uint8Array#get:length - local.get $separator - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/util/string/joinIntegerArray - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/typedarray/Uint8Array#toString (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 10000 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/typedarray/Uint8Array#join - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/string/String.__eq (param $left i32) (param $right i32) (result i32) - (local $leftLength i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $left - local.get $right - i32.eq - if - i32.const 1 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $left - i32.const 0 - i32.eq - if (result i32) - i32.const 1 - else - local.get $right - i32.const 0 - i32.eq - end - if - i32.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $left - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/string/String#get:length - local.set $leftLength - local.get $leftLength - local.get $right - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/string/String#get:length - i32.ne - if - i32.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $left - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 0 - local.get $right - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 0 - local.get $leftLength - call $~lib/util/string/compareImpl - i32.eqz - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/string/String.__ne (param $left i32) (param $right i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $left - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $right - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/string/String.__eq - i32.eqz - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/test/Assert#isEqual<~lib/string/String> (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) - (local $actualDisplay i32) - (local $expectDisplay i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - local.get $actual - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $expected - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/string/String.__ne - if - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - call $assembly/test/Assert#set:isOkay - global.get $~lib/memory/__stack_pointer - local.get $actual - local.tee $actualDisplay - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $expected - local.tee $expectDisplay - i32.store offset=12 - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - call $assembly/test/Assert#get:errors - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - global.get $~lib/memory/__stack_pointer - local.get $actualDisplay - local.tee $6 - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $expectDisplay - local.tee $7 - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $8 - i32.store offset=28 - i32.const 10128 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 1 - local.get $6 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=32 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 10128 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 3 - local.get $7 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=32 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 10128 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 5 - local.get $8 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=32 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 10128 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=16 - local.get $9 - i32.const 4080 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=32 - local.get $9 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/array/Array<~lib/string/String>#push - drop - end - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/memory.test~anonymous|2 (param $$0 i32) (result i32) - (local $builder i32) - (local $mem i32) - (local $out i32) - (local $data i32) - (local $5 i32) - (local $a i32) - (local $b i32) - (local $c i32) - (local $assert i32) - (local $10 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - global.get $assembly/memory-page/Access.Write - global.get $assembly/memory-page/RESERVED_MEMORY - i32.const 0 - i32.const 1 - call $~lib/typedarray/Uint8Array#constructor - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/MemoryBuilder#setData - drop - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - global.get $assembly/memory-page/Access.Write - global.get $assembly/memory-page/RESERVED_PAGES - i32.const 1 - i32.add - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i32.shl - i32.const 0 - i32.const 1 - call $~lib/typedarray/Uint8Array#constructor - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/MemoryBuilder#setData - drop - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $mem - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 16 - call $~lib/typedarray/Uint8Array#constructor - local.tee $out - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $out - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - call $~lib/typedarray/Uint8Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $data - i32.store offset=20 - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - i32.const 4 - i32.const 2 - i32.const 4 - i32.const 9952 - call $~lib/rt/__newArray - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - i32.const 0 - call $~lib/typedarray/Uint8Array#set<~lib/array/Array> - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/PAGE_SIZE - i32.add - i32.const 10 - i32.sub - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/Memory#bytesWrite - local.tee $a - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/PAGE_SIZE - i32.add - i32.const 9 - i32.sub - local.get $out - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/Memory#bytesRead - local.tee $b - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/PAGE_SIZE - i32.const 2 - i32.mul - i32.add - local.get $out - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/memory/Memory#bytesRead - local.tee $c - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=36 - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $a - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 8944 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $a - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9200 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $a - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:fault - i32.const 0 - i32.const 8944 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $b - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 9248 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $b - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9296 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $b - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:fault - i32.const 0 - i32.const 9248 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $c - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 1 - i32.const 9728 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $c - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - call $assembly/memory/MaybePageFault#get:isAccess - i32.const 0 - i32.const 9776 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $out - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=48 - local.get $10 - call $~lib/typedarray/Uint8Array#toString - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - i32.const 10032 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - i32.const 4080 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=44 - local.get $10 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=4 - local.get $10 - local.get $data - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=48 - local.get $10 - call $~lib/typedarray/Uint8Array#toString - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=8 - local.get $10 - i32.const 10176 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=40 - local.get $10 - i32.const 4080 - local.set $10 - global.get $~lib/memory/__stack_pointer - local.get $10 - i32.store offset=44 - local.get $10 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $10 - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $10 - return - ) - (func $start:assembly/memory.test~anonymous|3 (param $$0 i32) (result i32) - (local $mem i32) - (local $out i32) - (local $a i32) - (local $b i32) - (local $c i32) - (local $d i32) - (local $e i32) - (local $assert i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - global.get $assembly/memory-page/Access.Read - global.get $assembly/memory-page/RESERVED_MEMORY - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MemoryBuilder#setData - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $assembly/memory/MemoryBuilder#build@varargs - local.tee $mem - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.tee $out - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - local.get $out - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/memory/Memory#bytesRead - local.tee $a - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - i32.const 0 - local.get $out - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/memory/Memory#bytesWrite - local.tee $b - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/RESERVED_MEMORY - i32.add - local.get $out - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/memory/Memory#bytesRead - local.tee $c - i32.store offset=28 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - global.get $assembly/memory-page/RESERVED_MEMORY - global.get $assembly/memory-page/RESERVED_MEMORY - i32.add - local.get $out - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/memory/Memory#bytesRead - local.tee $d - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - local.get $mem - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - global.get $assembly/memory-page/RESERVED_MEMORY - local.get $out - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/memory/Memory#bytesWrite - local.tee $e - i32.store offset=36 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=40 - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $a - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 8944 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $b - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 9248 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $c - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 9728 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $d - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 10448 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store - local.get $9 - local.get $e - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/memory/MaybePageFault#get:isFault - i32.const 0 - i32.const 10496 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $start:assembly/memory.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 8496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 9344 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 9376 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 9824 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 9856 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 10288 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - i32.const 10320 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 10544 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/memory.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions/jump~anonymous|0 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:a - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/instructions/outcome/dJump (param $address i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.DynamicJump - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $address - call $assembly/instructions/outcome/OutcomeData#set:dJump - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/jump~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $address i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - local.get $address - call $assembly/instructions/outcome/dJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/jump~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/outcome/staticJump - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/jump~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $address i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:d - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - local.get $address - call $assembly/instructions/outcome/dJump - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/instructions/outcome/status (param $result i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $result - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/instructions/outcome/hostCall (param $id i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Result.HOST - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $id - call $assembly/instructions/outcome/OutcomeData#set:exitCode - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/misc~anonymous|3 (param $args i32) (param $$1 i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $assembly/arguments/Args#get:a - call $assembly/instructions/outcome/hostCall - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/memory/Memory#sbrk (param $this i32) (param $amount i32) (result i32) - (local $freeMemoryStart i32) - (local $newSbrk i64) - (local $pageIdx i32) - (local $i i32) - (local $page i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $freeMemoryStart - i32.store - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $amount - i32.const 0 - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:sbrkAddress - i64.extend_i32_u - local.get $amount - i64.extend_i32_u - i64.add - local.set $newSbrk - local.get $newSbrk - global.get $assembly/memory/MEMORY_SIZE - i64.ge_s - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Result#get:fault - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - i32.const 1 - call $assembly/memory/MaybePageFault#set:isFault - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $newSbrk - i32.wrap_i64 - call $assembly/memory/Memory#set:sbrkAddress - local.get $newSbrk - i64.const 1 - i64.sub - global.get $assembly/memory-page/PAGE_SIZE_SHIFT - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - local.set $pageIdx - local.get $pageIdx - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.eq - if - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory/Memory#get:lastAllocatedPage - i32.const 1 - i32.add - local.set $i - loop $for-loop|0 - local.get $i - local.get $pageIdx - i32.le_s - if - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/memory/Memory#get:arena - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - call $assembly/memory-page/Arena#acquire - local.tee $page - i32.store offset=12 - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory/Memory#get:pages - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $i - i32.const 0 - global.get $assembly/memory-page/Access.Write - local.get $page - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=16 - local.get $7 - call $assembly/memory-page/Page#constructor - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $"~lib/map/Map#set" - drop - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=4 - local.get $7 - local.get $pageIdx - call $assembly/memory/Memory#set:lastAllocatedPage - local.get $freeMemoryStart - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $assembly/instructions/outcome/okOrFault (param $pageFault i32) (result i32) - (local $r i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/instructions/outcome/OutcomeData#constructor - local.tee $r - i32.store - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - global.get $assembly/instructions/outcome/Outcome.Result - call $assembly/instructions/outcome/OutcomeData#set:outcome - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MaybePageFault#get:isAccess - if (result i32) - global.get $assembly/instructions/outcome/Result.FAULT_ACCESS - else - global.get $assembly/instructions/outcome/Result.FAULT - end - call $assembly/instructions/outcome/OutcomeData#set:result - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $pageFault - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/memory/MaybePageFault#get:fault - call $assembly/instructions/outcome/OutcomeData#set:exitCode - end - local.get $r - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/instructions/misc~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#sbrk - local.tee $res - i32.store offset=12 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - i64.const 32 - i64.shl - i64.add - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/load~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/load~anonymous|2 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|3 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU16 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getI16 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $l i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 2 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/Result#set:fault - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.const 15 - i32.and - i32.shl - i32.or - local.set $l - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $l - call $assembly/instructions/utils/u16SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getU32 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#set:fault - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/ChunkBytes#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - i64.extend_i32_u - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/memory/Result#get:ok - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $assembly/memory/ChunkBytes#get:bytes - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i64.extend_i32_u - i64.or - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/memory/Memory#getI32 (param $this i32) (param $address i32) (result i32) - (local $res i32) - (local $r i32) - (local $l i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 20 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - global.get $assembly/memory-page/Access.Read - local.get $address - i32.const 4 - call $assembly/memory/Memory#getBytes - local.tee $res - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/Result#constructor - local.tee $r - i32.store offset=8 - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/Result#set:fault - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 0 - call $~lib/staticarray/StaticArray#__get - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - call $~lib/staticarray/StaticArray#__get - i32.const 8 - i32.shl - i32.or - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 2 - call $~lib/staticarray/StaticArray#__get - i32.const 16 - i32.shl - i32.or - local.set $l - local.get $l - local.get $res - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=12 - local.get $5 - call $assembly/memory/ChunkBytes#get:bytes - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 3 - call $~lib/staticarray/StaticArray#__get - i32.const 24 - i32.shl - i32.or - local.set $l - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $l - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Result#set:ok - end - local.get $r - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 20 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getI32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#getU64 - local.tee $result - i32.store offset=8 - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Result#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/load~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI8 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI16 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getI32 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/load~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - call $assembly/memory/Memory#getU64 - local.tee $result - i32.store offset=8 - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/memory/MaybePageFault#get:isFault - i32.eqz - if - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:ok - call $~lib/staticarray/StaticArray#__set - end - local.get $result - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/memory/Result#get:fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/mov~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.eq - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/mov~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 0 - i64.ne - if - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $~lib/staticarray/StaticArray#__set - end - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/set~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.lt_u - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.lt_s - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.gt_u - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $cond i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.gt_s - local.set $cond - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $cond - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/set~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_u - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/set~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $registers - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $args - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.lt_s - if (result i64) - i64.const 1 - else - i64.const 0 - end - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/instructions/shift~anonymous|0 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|1 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|2 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|3 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|4 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|5 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $imm i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $imm - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $imm - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|6 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|7 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|8 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i32.rem_u - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|9 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|10 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|11 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|12 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shl - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|13 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $value i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - local.set $value - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $value - local.get $shift - i32.shr_u - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|14 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $regValue i64) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_32 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - local.set $regValue - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $regValue - local.get $shift - i64.extend_i32_u - i64.shr_s - i32.wrap_i64 - call $assembly/instructions/utils/u32SignExtend - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/shift~anonymous|15 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shl - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|16 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_u - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/shift~anonymous|17 (param $args i32) (param $registers i32) (param $$2 i32) (result i32) - (local $shift i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - global.get $assembly/instructions/shift/MAX_SHIFT_64 - i64.extend_i32_s - i64.rem_u - i32.wrap_i64 - local.set $shift - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:c - i64.extend_i32_u - call $assembly/instructions/utils/reg - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $shift - i64.extend_i32_u - i64.shr_s - call $~lib/staticarray/StaticArray#__set - call $assembly/instructions/outcome/ok - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|0 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU16 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 2 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.gt_s - if - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:first - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $value - i32.const 65535 - i32.and - i32.const 8 - i32.const 15 - i32.and - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - else - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/memory/Chunks#get:second - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 0 - local.get $value - i32.const 65535 - i32.and - i32.const 8 - i32.const 15 - i32.and - i32.shr_u - call $~lib/typedarray/Uint8Array#__set - end - local.get $res - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/memory/Chunks#get:fault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|1 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU32 (param $this i32) (param $address i32) (param $value i32) (result i32) - (local $res i32) - (local $v i32) - (local $len i32) - (local $i i32) - (local $i|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 4 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $value - local.set $v - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - local.get $v - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i32.const 8 - i32.shr_u - local.set $v - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i|7 - local.get $v - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i32.const 8 - i32.shr_u - local.set $v - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/instructions/store~anonymous|2 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/memory/Memory#setU32 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/memory/Memory#setU64 (param $this i32) (param $address i32) (param $value i64) (result i32) - (local $res i32) - (local $v i64) - (local $len i32) - (local $i i32) - (local $i|7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - global.get $assembly/memory-page/Access.Write - local.get $address - i32.const 8 - call $assembly/memory/Memory#getChunks - local.tee $res - i32.store offset=4 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/MaybePageFault#get:isFault - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $value - local.set $v - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:first - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i - local.get $v - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i64.const 8 - i64.shr_u - local.set $v - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $i|7 - loop $for-loop|1 - local.get $i|7 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/memory/Chunks#get:second - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $i|7 - local.get $v - i32.wrap_i64 - i32.const 255 - i32.and - call $~lib/typedarray/Uint8Array#__set - local.get $v - i64.const 8 - i64.shr_u - local.set $v - local.get $i|7 - i32.const 1 - i32.add - local.set $i|7 - br $for-loop|1 - end - end - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/memory/Chunks#get:fault - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/instructions/store~anonymous|3 (param $args i32) (param $_registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:a - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Memory#setU64 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|4 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|5 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|6 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|7 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $fault i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/arguments/Args#get:b - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $args - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/instructions/outcome/okOrFault - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/instructions/store~anonymous|8 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 255 - i32.and - call $assembly/memory/Memory#setU8 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|9 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 65535 - i32.and - call $assembly/memory/Memory#setU16 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|10 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/memory/Memory#setU32 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|11 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $pageFault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:b - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - call $assembly/memory/Memory#setU64 - local.tee $pageFault - i32.store offset=8 - local.get $pageFault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|12 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 255 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU8 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|13 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i64.const 65535 - i64.and - i32.wrap_i64 - call $assembly/memory/Memory#setU16 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|14 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - i32.wrap_i64 - call $assembly/memory/Memory#setU32 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/instructions/store~anonymous|15 (param $args i32) (param $registers i32) (param $memory i32) (result i32) - (local $address i32) - (local $fault i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/arguments/Args#get:a - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/arguments/Args#get:c - call $assembly/instructions/utils/u32SignExtend - i64.add - i32.wrap_i64 - local.set $address - global.get $~lib/memory/__stack_pointer - local.get $memory - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $address - local.get $registers - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/arguments/Args#get:b - i64.extend_i32_u - call $assembly/instructions/utils/reg - call $~lib/staticarray/StaticArray#__get - call $assembly/memory/Memory#setU64 - local.tee $fault - i32.store offset=12 - local.get $fault - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/instructions/outcome/okOrFault - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 0 - i32.shl - i32.add - i32.load8_u - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $start:assembly/codec~anonymous|0 (param $firstByte i32) (result i32) - (local $len i32) - (local $i i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - global.get $assembly/codec/MASKS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length - local.set $len - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $len - i32.const 255 - i32.and - i32.lt_u - if - local.get $firstByte - i32.const 255 - i32.and - global.get $assembly/codec/MASKS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $i - call $~lib/array/Array#__get - i32.ge_u - if - i32.const 8 - local.get $i - i32.sub - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 0 - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 1888 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 2 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - local.get $value - i32.store - i32.const 0 - drop - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/instructions - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 13920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/MISSING_INSTRUCTION - i32.const 13968 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - global.set $assembly/instructions/SBRK - global.get $~lib/memory/__stack_pointer - i32.const 231 - i32.const 2 - i32.const 36 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store offset=4 - local.get $0 - i32.const 0 - i32.const 14000 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 14032 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.Zero - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 5 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 6 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 7 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 8 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 9 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 10 - i32.const 14080 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 11 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 12 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 13 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 14 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 15 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 16 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 17 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 18 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 19 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 20 - i32.const 14112 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneExtImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 21 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 22 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 23 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 24 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 25 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 26 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 27 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 28 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 29 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 30 - i32.const 14160 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 31 - i32.const 14208 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 32 - i32.const 14256 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 33 - i32.const 14304 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 34 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 35 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 36 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 37 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 38 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 39 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 40 - i32.const 14352 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 41 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 42 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 43 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 44 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 45 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 46 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 47 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 48 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 49 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 50 - i32.const 14384 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 51 - i32.const 14432 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 52 - i32.const 14480 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 53 - i32.const 14528 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 54 - i32.const 14576 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 55 - i32.const 14624 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 56 - i32.const 14672 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 57 - i32.const 14720 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 58 - i32.const 14768 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 59 - i32.const 14816 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 60 - i32.const 14864 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 61 - i32.const 14912 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 62 - i32.const 14960 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 63 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 64 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 65 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 66 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 67 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 68 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 69 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 70 - i32.const 15008 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 71 - i32.const 15072 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 72 - i32.const 15136 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 73 - i32.const 15200 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegTwoImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 74 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 75 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 76 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 77 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 78 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 79 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 80 - i32.const 15264 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 81 - i32.const 15312 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 82 - i32.const 15360 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 83 - i32.const 15408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 84 - i32.const 15472 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 85 - i32.const 15536 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 86 - i32.const 15600 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 87 - i32.const 15664 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 88 - i32.const 15728 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 89 - i32.const 15792 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 90 - i32.const 15856 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.OneRegOneImmOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 91 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 92 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 93 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 94 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 95 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 96 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 97 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 98 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 99 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 100 - i32.const 15920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 101 - global.get $assembly/instructions/SBRK - call $~lib/array/Array#__set - local.get $0 - i32.const 102 - i32.const 15968 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 103 - i32.const 16032 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 104 - i32.const 16096 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 105 - i32.const 16160 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 106 - i32.const 16224 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 107 - i32.const 16288 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 108 - i32.const 16352 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 109 - i32.const 16400 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 110 - i32.const 16448 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 111 - i32.const 16496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 112 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 113 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 114 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 115 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 116 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 117 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 118 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 119 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 120 - i32.const 16544 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 121 - i32.const 16592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 122 - i32.const 16640 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 123 - i32.const 16688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 124 - i32.const 16736 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 125 - i32.const 16784 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 126 - i32.const 16832 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 127 - i32.const 16880 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 128 - i32.const 16928 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 129 - i32.const 16976 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 130 - i32.const 17024 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 131 - i32.const 17072 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 132 - i32.const 17120 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 133 - i32.const 17168 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 134 - i32.const 17216 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 135 - i32.const 17248 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 136 - i32.const 17296 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 137 - i32.const 17344 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 138 - i32.const 17392 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 139 - i32.const 17440 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 140 - i32.const 17488 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 141 - i32.const 17536 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 142 - i32.const 17584 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 143 - i32.const 17632 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 144 - i32.const 17680 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 145 - i32.const 17744 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 146 - i32.const 17808 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 147 - i32.const 17872 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 148 - i32.const 17920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 149 - i32.const 17968 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 150 - i32.const 18016 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 151 - i32.const 18064 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 152 - i32.const 18112 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 153 - i32.const 18160 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 154 - i32.const 18208 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 155 - i32.const 18256 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 156 - i32.const 18320 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 157 - i32.const 18384 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 158 - i32.const 18448 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 159 - i32.const 18496 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 160 - i32.const 18560 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 161 - i32.const 18608 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneImm - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 162 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 163 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 164 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 165 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 166 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 167 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 168 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 169 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 170 - i32.const 18672 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 171 - i32.const 18720 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 172 - i32.const 18768 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 173 - i32.const 18816 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 174 - i32.const 18864 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 175 - i32.const 18912 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegOneOff - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 176 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 177 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 178 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 179 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 180 - i32.const 18960 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.TwoRegTwoImm - i64.const 1 - i32.const 1 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 181 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 182 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 183 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 184 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 185 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 186 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 187 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 188 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 189 - global.get $assembly/instructions/MISSING_INSTRUCTION - call $~lib/array/Array#__set - local.get $0 - i32.const 190 - i32.const 19024 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 191 - i32.const 19056 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 192 - i32.const 19088 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 193 - i32.const 19120 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 194 - i32.const 19168 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 195 - i32.const 19216 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 196 - i32.const 19264 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 197 - i32.const 19312 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 198 - i32.const 19360 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 199 - i32.const 19408 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 200 - i32.const 19456 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 201 - i32.const 19488 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 202 - i32.const 19520 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 203 - i32.const 19552 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 204 - i32.const 19600 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 205 - i32.const 19648 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 206 - i32.const 19696 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 207 - i32.const 19744 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 208 - i32.const 19792 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 209 - i32.const 19840 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 210 - i32.const 19888 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 211 - i32.const 19920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 212 - i32.const 19952 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 213 - i32.const 19984 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 214 - i32.const 20032 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 215 - i32.const 20080 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 216 - i32.const 20128 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 217 - i32.const 20176 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 218 - i32.const 20224 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 219 - i32.const 20272 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 220 - i32.const 20320 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 221 - i32.const 20368 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 222 - i32.const 20416 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 223 - i32.const 20464 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 224 - i32.const 20512 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 225 - i32.const 20560 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 226 - i32.const 20592 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 227 - i32.const 20624 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 228 - i32.const 20656 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 229 - i32.const 20688 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - i32.const 230 - i32.const 20720 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - global.get $assembly/arguments/Arguments.ThreeReg - i64.const 1 - i32.const 0 - call $assembly/instructions/instruction - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/instructions/INSTRUCTIONS - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/Mask#constructor (param $this i32) (param $packedMask i32) (param $codeLength i32) (result i32) - (local $lastInstructionOffset i32) - (local $i i32) - (local $bits i32) - (local $index i32) - (local $b i32) - (local $isSet i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 37 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - call $assembly/program/Mask#set:bytesToSkip - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - local.get $codeLength - call $~lib/staticarray/StaticArray#constructor - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/Mask#set:bytesToSkip - i32.const 0 - local.set $lastInstructionOffset - local.get $packedMask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.const 1 - i32.sub - local.set $i - loop $for-loop|0 - local.get $i - i32.const 0 - i32.ge_s - if - local.get $packedMask - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - call $~lib/typedarray/Uint8Array#__get - local.set $bits - local.get $i - i32.const 8 - i32.mul - local.set $index - i32.const 7 - local.set $b - loop $for-loop|2 - local.get $b - i32.const 0 - i32.ge_s - if - local.get $bits - i32.const 128 - i32.and - local.set $isSet - local.get $bits - i32.const 1 - i32.const 7 - i32.and - i32.shl - local.set $bits - local.get $index - local.get $b - i32.add - local.get $codeLength - i32.lt_s - if - local.get $isSet - if (result i32) - i32.const 0 - else - local.get $lastInstructionOffset - i32.const 1 - i32.add - end - local.set $lastInstructionOffset - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $assembly/program/Mask#get:bytesToSkip - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $index - local.get $b - i32.add - local.get $lastInstructionOffset - global.get $assembly/program/MAX_SKIP - i32.const 1 - i32.add - i32.lt_u - if (result i32) - local.get $lastInstructionOffset - else - global.get $assembly/program/MAX_SKIP - i32.const 1 - i32.add - end - call $~lib/staticarray/StaticArray#__set - end - local.get $b - i32.const 1 - i32.sub - local.set $b - br $for-loop|2 - end - end - local.get $i - i32.const 1 - i32.sub - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $i i32) - (local $ptr i32) - (local $value f64) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/array/Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=8 - local.get $12 - call $~lib/array/Array#get:dataStart - local.set $sourceStart - i32.const 1 - i32.const 0 - i32.eq - drop - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $sourceLen - i32.lt_s - if - local.get $targetStart - local.get $i - i32.const 0 - i32.shl - i32.add - local.set $ptr - local.get $sourceStart - local.get $i - i32.const 3 - i32.shl - i32.add - f64.load - local.set $value - i32.const 0 - drop - i32.const 0 - i32.eqz - drop - local.get $ptr - local.get $value - local.get $value - f64.sub - f64.const 0 - f64.eq - if (result i32) - local.get $value - i32.trunc_sat_f64_u - else - i32.const 0 - end - i32.store8 - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program.test/u8arr (param $data i32) (result i32) - (local $ret i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $ret - i32.store offset=4 - local.get $ret - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#set<~lib/array/Array> - local.get $ret - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/staticarray/StaticArray#slice<~lib/array/Array> (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $length i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - (local $9 i32) - (local $10 i32) - (local $11 i32) - (local $12 i32) - (local $13 i32) - (local $sourceStart i32) - (local $size i32) - (local $out i32) - (local $outStart i32) - (local $18 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $18 - global.get $~lib/memory/__stack_pointer - local.get $18 - i32.store - local.get $18 - call $~lib/staticarray/StaticArray#get:length - local.set $length - local.get $start - i32.const 0 - i32.lt_s - if (result i32) - local.get $start - local.get $length - i32.add - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - else - local.get $start - local.tee $6 - local.get $length - local.tee $7 - local.get $6 - local.get $7 - i32.lt_s - select - end - local.set $start - local.get $end - i32.const 0 - i32.lt_s - if (result i32) - local.get $end - local.get $length - i32.add - local.tee $8 - i32.const 0 - local.tee $9 - local.get $8 - local.get $9 - i32.gt_s - select - else - local.get $end - local.tee $10 - local.get $length - local.tee $11 - local.get $10 - local.get $11 - i32.lt_s - select - end - local.set $end - local.get $end - local.get $start - i32.sub - local.tee $12 - i32.const 0 - local.tee $13 - local.get $12 - local.get $13 - i32.gt_s - select - local.set $length - local.get $this - local.get $start - i32.const 2 - i32.shl - i32.add - local.set $sourceStart - local.get $length - i32.const 2 - i32.shl - local.set $size - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $out - i32.store offset=4 - i32.const 1 - drop - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 2 - i32.const 40 - i32.const 0 - call $~lib/rt/__newArray - local.tee $out - i32.store offset=4 - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - local.get $18 - i32.store - local.get $18 - call $~lib/array/Array#get:dataStart - local.set $outStart - i32.const 0 - drop - local.get $outStart - local.get $sourceStart - local.get $size - memory.copy - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - ) - (func $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs (param $this i32) (param $start i32) (param $end i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - block $2of2 - block $1of2 - block $0of2 - block $outOfRange - global.get $~argumentsLength - br_table $0of2 $1of2 $2of2 $outOfRange - end - unreachable - end - i32.const 0 - local.set $start - end - global.get $~lib/builtins/i32.MAX_VALUE - local.set $end - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $start - local.get $end - call $~lib/staticarray/StaticArray#slice<~lib/array/Array> - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $value i32) - (local $sepLen i32) - (local $estLen i32) - (local $result i32) - (local $offset i32) - (local $value|9 i32) - (local $i i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 4080 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $lastIndex - i32.eqz - if - local.get $dataStart - i32.load - local.set $value - i32.const 0 - drop - i32.const 4 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 10 - call $~lib/util/number/utoa32 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $separator - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - local.set $sepLen - i32.const 10 - local.get $sepLen - i32.add - local.get $lastIndex - i32.mul - i32.const 10 - i32.add - local.set $estLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=4 - i32.const 0 - local.set $offset - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $lastIndex - i32.lt_s - if - local.get $dataStart - local.get $i - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $dataStart - local.get $lastIndex - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $estLen - local.get $offset - i32.gt_s - if - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.const 0 - local.get $offset - call $~lib/string/String#substring - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/array/Array#join (param $this i32) (param $separator i32) (result i32) - (local $ptr i32) - (local $len i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:dataStart - local.set $ptr - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/array/Array#get:length_ - local.set $len - i32.const 0 - drop - i32.const 1 - drop - local.get $ptr - local.get $len - local.get $separator - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/util/string/joinIntegerArray - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $assembly/test/Assert#isArrayEqual (param $this i32) (param $actual i32) (param $expected i32) (param $msg i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $actual - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $~lib/array/Array#get:length - local.get $expected - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $~lib/array/Array#get:length - i32.const 21008 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $msg - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $~lib/string/String#concat - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/test/Assert#isEqual - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $actual - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - local.get $4 - i32.const 10000 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=24 - local.get $4 - call $~lib/array/Array#join - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $~lib/string/String#toString - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $expected - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - local.get $4 - i32.const 10000 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=24 - local.get $4 - call $~lib/array/Array#join - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - call $~lib/string/String#toString - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - local.get $msg - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/test/Assert#isEqual<~lib/string/String> - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/Mask#isInstruction (param $this i32) (param $index i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - i64.extend_i32_u - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i64.extend_i32_s - i64.ge_u - if - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $index - call $~lib/staticarray/StaticArray#__get - i32.const 0 - i32.eq - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/program/Mask#skipBytesToNextInstruction (param $this i32) (param $i i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $i - i32.const 1 - i32.add - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/staticarray/StaticArray#get:length - i32.lt_u - if - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/program/Mask#get:bytesToSkip - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $i - i32.const 1 - i32.add - call $~lib/staticarray/StaticArray#__get - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - end - i32.const 0 - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $start:assembly/program.test~anonymous|0 (param $$0 i32) (result i32) - (local $1 i32) - (local $mask i32) - (local $assert i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 3 - i32.const 3 - i32.const 39 - i32.const 20848 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program.test/u8arr - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 21 - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/program/Mask#get:bytesToSkip - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - i32.const 0 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 21 - i32.const 2 - i32.const 40 - i32.const 20896 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isArrayEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 0 - call $assembly/program/Mask#isInstruction - i32.const 0 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 4 - call $assembly/program/Mask#isInstruction - i32.const 1 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 20 - call $assembly/program/Mask#skipBytesToNextInstruction - i32.const 0 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 22 - call $assembly/program/Mask#skipBytesToNextInstruction - i32.const 0 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/program.test~anonymous|1 (param $$0 i32) (result i32) - (local $1 i32) - (local $mask i32) - (local $assert i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 4 - i32.const 3 - i32.const 39 - i32.const 21200 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program.test/u8arr - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 32 - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/program/Mask#get:bytesToSkip - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - i32.const 0 - i32.const 0 - global.set $~argumentsLength - i32.const 0 - call $~lib/staticarray/StaticArray#slice<~lib/array/Array>@varargs - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 32 - i32.const 2 - i32.const 40 - i32.const 21264 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/test/Assert#isArrayEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 21616 - i32.const 1888 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/decodeArguments (param $kind i32) (param $data i32) (param $lim i32) (result i32) - (local $extended i32) - (local $i i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - global.get $assembly/arguments/REQUIRED_BYTES - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $kind - call $~lib/array/Array#__get - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/arguments/REQUIRED_BYTES - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $kind - call $~lib/array/Array#__get - call $~lib/typedarray/Uint8Array#constructor - local.tee $extended - i32.store offset=4 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - local.get $extended - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $i - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $i - call $~lib/typedarray/Uint8Array#__get - call $~lib/typedarray/Uint8Array#__set - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $extended - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $lim - i32.const 2 - global.set $~argumentsLength - global.get $assembly/arguments/DECODERS - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $kind - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $3) - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - end - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $lim - i32.const 2 - global.set $~argumentsLength - global.get $assembly/arguments/DECODERS - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - local.get $kind - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__get - i32.load - call_indirect (type $3) - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/program.test~anonymous|2 (param $$0 i32) (result i32) - (local $1 i32) - (local $data i32) - (local $args i32) - (local $assert i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 3 - i32.const 39 - i32.const 21552 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program.test/u8arr - local.tee $data - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - global.get $assembly/arguments/Arguments.OneImm - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 4 - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:a - i32.const -1 - i32.const 21744 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 0 - i32.const 21776 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 0 - i32.const 21808 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:d - i32.const 0 - i32.const 21840 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $start:assembly/program.test~anonymous|3 (param $$0 i32) (result i32) - (local $1 i32) - (local $data i32) - (local $args i32) - (local $assert i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 2 - i32.const 3 - i32.const 39 - i32.const 22000 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program.test/u8arr - local.tee $data - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - global.get $assembly/arguments/Arguments.OneImm - local.get $data - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - call $assembly/program/decodeArguments - local.tee $args - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:a - i32.const 5 - i32.const 21744 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:b - i32.const 0 - i32.const 21776 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:c - i32.const 0 - i32.const 21808 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $args - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/arguments/Args#get:d - i32.const 0 - i32.const 21840 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - call $assembly/test/Assert#isEqual - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/codec/Decoder#constructor (param $this i32) (param $source i32) (param $offset i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 45 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $source - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/codec/Decoder#set:source - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $offset - call $assembly/codec/Decoder#set:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/codec/Decoder#ensureBytes (param $this i32) (param $need i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#get:offset - local.get $need - i32.add - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/codec/Decoder#get:source - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $need - i32.const 10 - call $~lib/number/U32#toString - local.tee $2 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/codec/Decoder#get:source - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/typedarray/Uint8Array#get:length - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/codec/Decoder#get:offset - i32.sub - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=12 - i32.const 22624 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $2 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 22624 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 3 - local.get $3 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 22624 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 4080 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 22672 - i32.const 25 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/codec/ValOffset#constructor (param $this i32) (param $value i32) (param $offset i32) (result i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.const 46 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $value - call $assembly/codec/ValOffset#set:value - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $offset - call $assembly/codec/ValOffset#set:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - ) - (func $assembly/codec/decodeVarU32 (param $data i32) (result i32) - (local $length i32) - (local $first i32) - (local $3 i32) - (local $4 i32) - (local $msb i32) - (local $number i32) - (local $i i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - i32.const 1 - global.set $~argumentsLength - global.get $assembly/codec/variableLength - i32.load - call_indirect (type $0) - i32.const 255 - i32.and - local.set $length - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 0 - call $~lib/typedarray/Uint8Array#__get - local.set $first - local.get $length - i32.const 0 - i32.eq - if - i32.const 0 - local.get $first - i32.const 1 - call $assembly/codec/ValOffset#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - end - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - local.get $length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/typedarray/Uint8Array#get:length - i32.const 10 - call $~lib/number/I32#toString - local.tee $4 - i32.store offset=8 - i32.const 22896 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $3 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 22896 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 3 - local.get $4 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 22896 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 22672 - i32.const 108 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $first - i32.const 2 - i32.const 8 - local.get $length - i32.sub - call $~lib/math/ipow32 - i32.add - i32.const 2 - i32.const 8 - call $~lib/math/ipow32 - i32.sub - local.get $length - i32.const 8 - i32.mul - i32.shl - local.set $msb - i32.const 0 - local.set $number - local.get $length - i32.const 1 - i32.sub - local.set $i - loop $for-loop|0 - local.get $i - i32.const 0 - i32.ge_s - if - local.get $number - i32.const 8 - i32.shl - local.get $data - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - local.get $i - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.add - local.set $number - local.get $i - i32.const 1 - i32.sub - local.set $i - br $for-loop|0 - end - end - local.get $number - local.get $msb - i32.add - local.set $number - i32.const 0 - local.get $number - i32.const 1 - local.get $length - i32.add - call $assembly/codec/ValOffset#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $assembly/codec/Decoder#varU32 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - global.set $~argumentsLength - i32.const 0 - call $~lib/typedarray/Uint8Array#subarray@varargs - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/decodeVarU32 - local.tee $v - i32.store offset=12 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/ValOffset#get:offset - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $assembly/codec/ValOffset#get:value - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u8 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 1 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#bytes (param $this i32) (param $len i32) (result i32) - (local $v i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $len - call $assembly/codec/Decoder#ensureBytes - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:source - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $len - i32.add - call $~lib/typedarray/Uint8Array#subarray - local.tee $v - i32.store offset=8 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/codec/Decoder#get:offset - local.get $len - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/JumpTable#constructor (param $this i32) (param $itemBytes i32) (param $data i32) (result i32) - (local $jumps i32) - (local $i i32) - (local $num i64) - (local $j i32) - (local $nextNum i64) - (local $isOverflow i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 42 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - i32.const 0 - call $assembly/program/JumpTable#set:jumps - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $itemBytes - i32.const 255 - i32.and - i32.const 0 - i32.gt_u - if (result i32) - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - local.get $itemBytes - i32.const 255 - i32.and - i32.div_s - else - i32.const 0 - end - call $~lib/staticarray/StaticArray#constructor - local.tee $jumps - i32.store offset=8 - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.lt_s - if - i64.const 0 - local.set $num - local.get $itemBytes - i32.const 1 - i32.sub - i32.const 255 - i32.and - local.set $j - loop $for-loop|1 - local.get $j - i32.const 0 - i32.ge_s - if - local.get $num - i64.const 8 - i64.shl - local.set $nextNum - local.get $nextNum - local.get $num - i64.lt_u - local.set $isOverflow - local.get $nextNum - local.get $data - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - local.get $j - i32.add - call $~lib/typedarray/Uint8Array#__get - i64.extend_i32_u - i64.add - local.set $nextNum - local.get $isOverflow - if (result i32) - i32.const 1 - else - local.get $nextNum - local.get $num - i64.lt_u - end - local.set $isOverflow - local.get $isOverflow - if (result i64) - global.get $~lib/builtins/u64.MAX_VALUE - else - local.get $nextNum - end - local.set $num - local.get $j - i32.const 1 - i32.sub - local.set $j - br $for-loop|1 - end - end - local.get $jumps - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $i - local.get $itemBytes - i32.const 255 - i32.and - i32.div_s - local.get $num - call $~lib/staticarray/StaticArray#__set - local.get $i - local.get $itemBytes - i32.const 255 - i32.and - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=4 - local.get $9 - local.get $jumps - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=12 - local.get $9 - call $assembly/program/JumpTable#set:jumps - local.get $this - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - ) - (func $~lib/staticarray/StaticArray#__set (param $this i32) (param $index i32) (param $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 93 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - local.get $value - call $~lib/staticarray/StaticArray#__uset - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 21616 - i32.const 1888 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/staticarray/StaticArray#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.ge_u - if - i32.const 480 - i32.const 1408 - i32.const 78 - i32.const 41 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.set $value - i32.const 0 - drop - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/BasicBlocks#constructor (param $this i32) (param $code i32) (param $mask i32) (result i32) - (local $len i32) - (local $isStartOrEnd i32) - (local $n i32) - (local $isInstructionInMask i32) - (local $skipArgs i32) - (local $iData i32) - (local $isTerminating i32) - (local $newBlockStart i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.const 43 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - call $assembly/program/BasicBlocks#set:isStartOrEnd - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/typedarray/Uint8Array#get:length - local.set $len - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $len - call $~lib/staticarray/StaticArray#constructor - local.tee $isStartOrEnd - i32.store offset=8 - local.get $len - i32.const 0 - i32.gt_s - if - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - i32.const 0 - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set - end - i32.const 0 - local.set $n - loop $for-loop|0 - local.get $n - local.get $len - i32.lt_s - if - block $for-continue|0 - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $assembly/program/Mask#isInstruction - local.set $isInstructionInMask - local.get $isInstructionInMask - i32.eqz - if - br $for-continue|0 - end - local.get $mask - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $assembly/program/Mask#skipBytesToNextInstruction - local.set $skipArgs - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - call $~lib/array/Array#get:length - i32.const 255 - i32.and - i32.ge_u - if (result i32) - global.get $assembly/instructions/MISSING_INSTRUCTION - else - global.get $assembly/instructions/INSTRUCTIONS - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $code - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - local.get $n - call $~lib/typedarray/Uint8Array#__get - call $~lib/array/Array#__get - end - local.set $iData - local.get $iData - call $assembly/instructions/Instruction#get:isTerminating - local.set $isTerminating - local.get $isTerminating - if - local.get $n - i32.const 1 - i32.add - local.get $skipArgs - i32.add - local.set $newBlockStart - local.get $newBlockStart - local.get $len - i32.lt_s - if - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $newBlockStart - global.get $assembly/program/BasicBlock.START - call $~lib/staticarray/StaticArray#__set - end - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $n - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - local.get $n - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.END - i32.or - call $~lib/staticarray/StaticArray#__set - end - end - local.get $n - i32.const 1 - i32.add - local.set $n - br $for-loop|0 - end - end - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=4 - local.get $11 - local.get $isStartOrEnd - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store offset=12 - local.get $11 - call $assembly/program/BasicBlocks#set:isStartOrEnd - local.get $this - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - ) - (func $assembly/program/Program#constructor (param $this i32) (param $code i32) (param $mask i32) (param $jumpTable i32) (param $basicBlocks i32) (result i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.const 41 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $code - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:code - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:mask - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:jumpTable - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - local.get $basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/Program#set:basicBlocks - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - ) - (func $assembly/program/deblob (param $program i32) (result i32) - (local $decoder i32) - (local $jumpTableLength i32) - (local $jumpTableItemLength i32) - (local $codeLength i32) - (local $jumpTableLengthInBytes i32) - (local $rawJumpTable i32) - (local $rawCode i32) - (local $rawMask i32) - (local $mask i32) - (local $jumpTable i32) - (local $basicBlocks i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 44 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $program - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=4 - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#varU32 - local.set $jumpTableLength - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#u8 - local.set $jumpTableItemLength - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/codec/Decoder#varU32 - local.set $codeLength - local.get $jumpTableLength - local.get $jumpTableItemLength - i32.mul - local.set $jumpTableLengthInBytes - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $jumpTableLengthInBytes - call $assembly/codec/Decoder#bytes - local.tee $rawJumpTable - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - call $assembly/codec/Decoder#bytes - local.tee $rawCode - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - i32.const 7 - i32.add - i32.const 8 - i32.div_u - call $assembly/codec/Decoder#bytes - local.tee $rawMask - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $rawMask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $codeLength - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $jumpTableItemLength - local.get $rawJumpTable - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - call $assembly/program/JumpTable#constructor - local.tee $jumpTable - i32.store offset=24 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $rawCode - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $mask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - call $assembly/program/BasicBlocks#constructor - local.tee $basicBlocks - i32.store offset=32 - i32.const 0 - local.get $rawCode - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store - local.get $12 - local.get $mask - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=28 - local.get $12 - local.get $jumpTable - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=36 - local.get $12 - local.get $basicBlocks - local.set $12 - global.get $~lib/memory/__stack_pointer - local.get $12 - i32.store offset=40 - local.get $12 - call $assembly/program/Program#constructor - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 44 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $~lib/string/String.__concat (param $left i32) (param $right i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $left - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $right - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/string/String#concat - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/program/Mask#toString (param $this i32) (result i32) - (local $v i32) - (local $i i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 22944 - local.tee $v - i32.store - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $assembly/program/Mask#get:bytesToSkip - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=24 - local.get $3 - call $assembly/program/Mask#get:bytesToSkip - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=20 - local.get $3 - local.get $i - call $~lib/staticarray/StaticArray#__get - i32.const 10 - call $~lib/number/U32#toString - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=12 - local.get $3 - i32.const 22976 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=16 - local.get $3 - call $~lib/string/String#concat - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $~lib/string/String.__concat - local.tee $v - i32.store - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $v - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - i32.const 23008 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=8 - local.get $3 - call $~lib/string/String#concat - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/program/JumpTable#toString (param $this i32) (result i32) - (local $v i32) - (local $i i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 23280 - local.tee $v - i32.store - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $assembly/program/JumpTable#get:jumps - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - global.get $~lib/memory/__stack_pointer - local.get $i - i32.const 10 - call $~lib/number/I32#toString - local.tee $3 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $assembly/program/JumpTable#get:jumps - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - local.get $i - call $~lib/staticarray/StaticArray#__get - i32.const 10 - call $~lib/number/U64#toString - local.tee $4 - i32.store offset=24 - i32.const 23360 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 0 - local.get $3 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 23360 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 2 - local.get $4 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 23360 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/string/String.__concat - local.tee $v - i32.store - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $v - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - i32.const 23008 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=8 - local.get $5 - call $~lib/string/String#concat - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $assembly/program/BasicBlocks#toString (param $this i32) (result i32) - (local $v i32) - (local $i i32) - (local $t i32) - (local $isStart i32) - (local $isEnd i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 23456 - local.tee $v - i32.store - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $~lib/staticarray/StaticArray#get:length - i32.lt_s - if - global.get $~lib/memory/__stack_pointer - i32.const 4080 - local.tee $t - i32.store offset=12 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $i - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.START - i32.and - i32.const 0 - i32.gt_s - local.set $isStart - global.get $~lib/memory/__stack_pointer - local.get $t - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $isStart - if (result i32) - i32.const 23504 - else - i32.const 4080 - end - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String.__concat - local.tee $t - i32.store offset=12 - local.get $this - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $assembly/program/BasicBlocks#get:isStartOrEnd - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $i - call $~lib/staticarray/StaticArray#__get - global.get $assembly/program/BasicBlock.END - i32.and - i32.const 0 - i32.gt_s - local.set $isEnd - global.get $~lib/memory/__stack_pointer - local.get $t - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $isEnd - if (result i32) - i32.const 23536 - else - i32.const 4080 - end - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String.__concat - local.tee $t - i32.store offset=12 - local.get $t - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $~lib/string/String#get:length - i32.const 0 - i32.gt_s - if - global.get $~lib/memory/__stack_pointer - local.get $v - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - global.get $~lib/memory/__stack_pointer - local.get $i - i32.const 10 - call $~lib/number/I32#toString - local.tee $6 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $t - local.tee $7 - i32.store offset=20 - i32.const 23568 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 0 - local.get $6 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 23568 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 2 - local.get $7 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 23568 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String.__concat - local.tee $v - i32.store - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $v - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 23008 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $8 - return - ) - (func $start:assembly/program.test~anonymous|4 (param $$0 i32) (result i32) - (local $1 i32) - (local $raw i32) - (local $program i32) - (local $assert i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 41 - i32.const 3 - i32.const 39 - i32.const 22144 - call $~lib/rt/__newArray - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program.test/u8arr - local.tee $raw - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - local.get $raw - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program/deblob - local.tee $program - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $program - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=32 - local.get $5 - call $assembly/program/Program#get:mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/program/Mask#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 23040 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $program - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=32 - local.get $5 - call $assembly/program/Program#get:jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/program/JumpTable#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 23408 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - local.get $program - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=32 - local.get $5 - call $assembly/program/Program#get:basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=28 - local.get $5 - call $assembly/program/BasicBlocks#toString - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=16 - local.get $5 - i32.const 23616 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=20 - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=24 - local.get $5 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#indexOf (param $this i32) (param $value i32) (param $fromIndex i32) (result i32) - (local $len i32) - (local $4 i32) - (local $5 i32) - (local $ptr i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ - local.set $len - local.get $len - i32.const 0 - i32.eq - if (result i32) - i32.const 1 - else - local.get $fromIndex - local.get $len - i32.ge_s - end - if - i32.const -1 - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $fromIndex - i32.const 0 - i32.lt_s - if - local.get $len - local.get $fromIndex - i32.add - local.tee $4 - i32.const 0 - local.tee $5 - local.get $4 - local.get $5 - i32.gt_s - select - local.set $fromIndex - end - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart - local.set $ptr - loop $while-continue|0 - local.get $fromIndex - local.get $len - i32.lt_s - if - local.get $ptr - local.get $fromIndex - i32.const 2 - i32.shl - i32.add - i32.load - local.get $value - i32.eq - if - local.get $fromIndex - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - end - local.get $fromIndex - i32.const 1 - i32.add - local.set $fromIndex - br $while-continue|0 - end - end - i32.const -1 - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $assembly/program.test/opcode (param $search i32) (result f64) - (local $idx i32) - (local $2 i32) - (local $3 f64) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $assembly/instructions-exe/RUN - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $search - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - i32.const 0 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#indexOf - local.set $idx - local.get $idx - i32.const 0 - i32.lt_s - if - i32.const 24080 - i32.const 24192 - i32.const 152 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $idx - f64.convert_i32_s - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array#__set (param $this i32) (param $index i32) (param $value f64) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - local.get $index - i32.const 0 - i32.lt_s - if - i32.const 480 - i32.const 1888 - i32.const 130 - i32.const 22 - call $~lib/builtins/abort - unreachable - end - local.get $this - local.get $index - i32.const 1 - i32.add - i32.const 3 - i32.const 1 - call $~lib/array/ensureCapacity - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $index - i32.const 1 - i32.add - call $~lib/array/Array#set:length_ - end - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 3 - i32.shl - i32.add - local.get $value - f64.store - i32.const 0 - drop - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $start:assembly/program.test~anonymous|5 (param $$0 i32) (result i32) - (local $1 i32) - (local $code i32) - (local $3 i32) - (local $mask i32) - (local $basicBlocks i32) - (local $assert i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 40 - memory.fill - global.get $~lib/memory/__stack_pointer - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.const 3 - i32.const 39 - i32.const 0 - call $~lib/rt/__newArray - local.tee $1 - i32.store offset=4 - local.get $1 - i32.const 0 - global.get $assembly/instructions/misc/trap - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/program.test/opcode - call $~lib/array/Array#__set - local.get $1 - i32.const 1 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 2 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 3 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 4 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 5 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 6 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 7 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 8 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 9 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 10 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 11 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 12 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 13 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 14 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 15 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 16 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 17 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 18 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 19 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 20 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 21 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 22 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 23 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 24 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 25 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 26 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 27 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 28 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 29 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 30 - f64.const 0 - call $~lib/array/Array#__set - local.get $1 - i32.const 31 - global.get $assembly/instructions/jump/jump_ind - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/program.test/opcode - call $~lib/array/Array#__set - local.get $1 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $assembly/program.test/u8arr - local.tee $code - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 4 - i32.const 3 - i32.const 39 - i32.const 24272 - call $~lib/rt/__newArray - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/program.test/u8arr - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - i32.const 32 - call $assembly/program/Mask#constructor - local.tee $mask - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $code - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $mask - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - call $assembly/program/BasicBlocks#constructor - local.tee $basicBlocks - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=24 - local.get $assert - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $mask - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=36 - local.get $7 - call $assembly/program/Mask#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - i32.const 24336 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=28 - local.get $7 - i32.const 4080 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=32 - local.get $7 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $basicBlocks - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=36 - local.get $7 - call $assembly/program/BasicBlocks#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=8 - local.get $7 - i32.const 24608 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=28 - local.get $7 - i32.const 4080 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=32 - local.get $7 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 40 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $start:assembly/program.test~anonymous|6 (param $$0 i32) (result i32) - (local $1 i32) - (local $jumpTable i32) - (local $assert i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 28 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 10 - i32.const 30 - i32.const 3 - i32.const 39 - i32.const 24880 - call $~lib/rt/__newArray - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/program.test/u8arr - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/program/JumpTable#constructor - local.tee $jumpTable - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=12 - local.get $assert - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - local.get $jumpTable - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=24 - local.get $4 - call $assembly/program/JumpTable#toString - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 25152 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=16 - local.get $4 - i32.const 4080 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=20 - local.get $4 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/program.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - call $start:assembly/program - global.get $~lib/memory/__stack_pointer - i32.const 7 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 20752 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 21056 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 1 - i32.const 21088 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 21424 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 2 - i32.const 21456 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 21872 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 3 - i32.const 21904 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 22048 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 4 - i32.const 22080 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 23920 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 5 - i32.const 23952 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 24736 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - i32.const 6 - i32.const 24768 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 25360 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/program.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/typedarray/Uint8Array#set<~lib/array/Array> (param $this i32) (param $source i32) (param $offset i32) - (local $target i32) - (local $source|4 i32) - (local $offset|5 i32) - (local $sourceLen i32) - (local $targetStart i32) - (local $sourceStart i32) - (local $9 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.tee $target - i32.store - global.get $~lib/memory/__stack_pointer - local.get $source - local.tee $source|4 - i32.store offset=4 - local.get $offset - local.set $offset|5 - i32.const 0 - drop - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/array/Array#get:length - local.set $sourceLen - local.get $offset|5 - i32.const 0 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $sourceLen - local.get $offset|5 - i32.add - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/typedarray/Uint8Array#get:length - i32.gt_s - end - if - i32.const 480 - i32.const 720 - i32.const 1902 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $target - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/arraybuffer/ArrayBufferView#get:dataStart - local.get $offset|5 - i32.const 0 - i32.shl - i32.add - local.set $targetStart - local.get $source|4 - local.set $9 - global.get $~lib/memory/__stack_pointer - local.get $9 - i32.store offset=8 - local.get $9 - call $~lib/array/Array#get:dataStart - local.set $sourceStart - i32.const 0 - i32.eqz - drop - local.get $targetStart - local.get $sourceStart - local.get $sourceLen - i32.const 0 - i32.shl - memory.copy - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/program/liftBytes (param $data i32) (result i32) - (local $p i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:length - call $~lib/typedarray/Uint8Array#constructor - local.tee $p - i32.store offset=4 - local.get $p - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $data - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=8 - local.get $2 - i32.const 0 - call $~lib/typedarray/Uint8Array#set<~lib/array/Array> - local.get $p - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u24 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 3 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 3 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u16 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 2 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.const 15 - i32.and - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#u32 (param $this i32) (result i32) - (local $v i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - i32.const 4 - call $assembly/codec/Decoder#ensureBytes - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - call $~lib/typedarray/Uint8Array#__get - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 1 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 8 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 2 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 16 - i32.shl - i32.or - local.set $v - local.get $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:source - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 3 - i32.add - call $~lib/typedarray/Uint8Array#__get - i32.const 24 - i32.shl - i32.or - local.set $v - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $assembly/codec/Decoder#get:offset - i32.const 4 - i32.add - call $assembly/codec/Decoder#set:offset - local.get $v - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $assembly/codec/Decoder#isExhausted (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#get:offset - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $assembly/codec/Decoder#get:source - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - i32.ge_s - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $assembly/codec/Decoder#finish (param $this i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store offset=8 - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $assembly/codec/Decoder#isExhausted - i32.eqz - if - i32.const 25808 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=12 - local.get $1 - call $assembly/codec/Decoder#get:source - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $~lib/typedarray/Uint8Array#get:length - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/codec/Decoder#get:offset - i32.sub - i32.const 10 - call $~lib/number/I32#toString - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/string/String#concat - i32.const 22672 - i32.const 31 - i32.const 7 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 16 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/memory/MemoryBuilder#setEmpty (param $this i32) (param $access i32) (param $address i32) (param $len i32) (result i32) - (local $endAddress i32) - (local $currentAddress i32) - (local $6 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $address - local.get $len - i32.add - local.set $endAddress - local.get $address - local.set $currentAddress - loop $for-loop|0 - local.get $currentAddress - local.get $endAddress - i32.lt_u - if - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - local.get $6 - i32.store - local.get $6 - local.get $access - local.get $currentAddress - call $assembly/memory/MemoryBuilder#getOrCreatePageForAddress - drop - local.get $currentAddress - global.get $assembly/memory-page/PAGE_SIZE - i32.add - local.set $currentAddress - br $for-loop|0 - end - end - local.get $this - local.set $6 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $6 - return - ) - (func $assembly/spi/StandardProgram#constructor (param $this i32) (param $program i32) (param $memory i32) (param $registers i32) (result i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 47 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:program - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:memory - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - local.get $registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:registers - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - i32.const 0 - call $~lib/typedarray/Uint8Array#constructor - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=8 - local.get $4 - call $assembly/spi/StandardProgram#set:metadata - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i32.const 0 - call $assembly/spi/StandardProgram#set:pc - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - i64.const 0 - call $assembly/spi/StandardProgram#set:gas - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - ) - (func $assembly/spi/decodeSpi (param $data i32) (param $args i32) (result i32) - (local $argsLength i32) - (local $3 i32) - (local $4 i32) - (local $decoder i32) - (local $roLength i32) - (local $rwLength i32) - (local $heapPages i32) - (local $stackSize i32) - (local $roMem i32) - (local $rwMem i32) - (local $codeLength i32) - (local $code i32) - (local $program i32) - (local $builder i32) - (local $heapStart i32) - (local $heapZerosStart i32) - (local $heapZerosLength i32) - (local $heapZerosEnd i32) - (local $stackLength i32) - (local $stackStart i32) - (local $memory i32) - (local $registers i32) - (local $24 i32) - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 52 - memory.fill - local.get $args - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $~lib/typedarray/Uint8Array#get:length - local.set $argsLength - local.get $argsLength - global.get $assembly/spi/MAX_ARGS_LEN - i32.gt_u - if - global.get $~lib/memory/__stack_pointer - local.get $argsLength - i32.const 10 - call $~lib/number/U32#toString - local.tee $3 - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - global.get $assembly/spi/MAX_ARGS_LEN - i32.const 10 - call $~lib/number/U32#toString - local.tee $4 - i32.store offset=8 - i32.const 25696 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 1 - local.get $3 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 25696 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 3 - local.get $4 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 25696 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 4080 - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - i32.const 25744 - i32.const 18 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 0 - local.get $data - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 0 - call $assembly/codec/Decoder#constructor - local.tee $decoder - i32.store offset=16 - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#u24 - local.set $roLength - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#u24 - local.set $rwLength - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#u16 - local.set $heapPages - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#u24 - local.set $stackSize - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - local.get $roLength - call $assembly/codec/Decoder#bytes - local.tee $roMem - i32.store offset=20 - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - local.get $rwLength - call $assembly/codec/Decoder#bytes - local.tee $rwMem - i32.store offset=24 - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#u32 - local.set $codeLength - global.get $~lib/memory/__stack_pointer - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - local.get $codeLength - call $assembly/codec/Decoder#bytes - local.tee $code - i32.store offset=28 - local.get $decoder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/codec/Decoder#finish - global.get $~lib/memory/__stack_pointer - local.get $code - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - call $assembly/program/deblob - local.tee $program - i32.store offset=32 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/memory/MemoryBuilder#constructor - local.tee $builder - i32.store offset=36 - i32.const 2 - global.get $assembly/memory-page/SEGMENT_SIZE - i32.mul - local.get $roLength - call $assembly/spi/alignToSegmentSize - i32.add - local.set $heapStart - local.get $heapStart - local.get $rwLength - call $assembly/spi/alignToPageSize - i32.add - local.set $heapZerosStart - local.get $heapPages - i32.const 65535 - i32.and - global.get $assembly/memory-page/PAGE_SIZE - i32.mul - local.set $heapZerosLength - local.get $heapZerosStart - local.get $heapZerosLength - i32.add - local.set $heapZerosEnd - local.get $stackSize - call $assembly/spi/alignToPageSize - local.set $stackLength - global.get $assembly/spi/STACK_SEGMENT_END - local.get $stackLength - i32.sub - local.set $stackStart - local.get $roLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - global.get $assembly/memory-page/Access.Read - global.get $assembly/memory-page/SEGMENT_SIZE - local.get $roMem - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $assembly/memory/MemoryBuilder#setData - drop - end - local.get $argsLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - global.get $assembly/memory-page/Access.Read - global.get $assembly/spi/ARGS_SEGMENT_START - local.get $args - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $assembly/memory/MemoryBuilder#setData - drop - end - local.get $rwLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - global.get $assembly/memory-page/Access.Write - local.get $heapStart - local.get $rwMem - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - call $assembly/memory/MemoryBuilder#setData - drop - end - local.get $heapZerosLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - global.get $assembly/memory-page/Access.Write - local.get $heapZerosStart - local.get $heapZerosLength - call $assembly/memory/MemoryBuilder#setEmpty - drop - end - local.get $stackLength - i32.const 0 - i32.gt_u - if - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - global.get $assembly/memory-page/Access.Write - local.get $stackStart - local.get $stackLength - call $assembly/memory/MemoryBuilder#setEmpty - drop - end - global.get $~lib/memory/__stack_pointer - local.get $builder - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - local.get $heapZerosEnd - call $assembly/memory/MemoryBuilder#build - local.tee $memory - i32.store offset=40 - global.get $~lib/memory/__stack_pointer - i32.const 0 - global.get $assembly/registers/NO_OF_REGISTERS - call $~lib/staticarray/StaticArray#constructor - local.tee $registers - i32.store offset=44 - local.get $registers - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 0 - i64.const 4294901760 - call $~lib/staticarray/StaticArray#__set - local.get $registers - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 1 - global.get $assembly/spi/STACK_SEGMENT_END - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - local.get $registers - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 7 - global.get $assembly/spi/ARGS_SEGMENT_START - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - local.get $registers - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - i32.const 8 - local.get $argsLength - i64.extend_i32_u - call $~lib/staticarray/StaticArray#__set - i32.const 0 - local.get $program - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store - local.get $24 - local.get $memory - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=12 - local.get $24 - local.get $registers - local.set $24 - global.get $~lib/memory/__stack_pointer - local.get $24 - i32.store offset=48 - local.get $24 - call $assembly/spi/StandardProgram#constructor - local.set $24 - global.get $~lib/memory/__stack_pointer - i32.const 52 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $24 - return - ) - (func $assembly/program/Program#toString (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program/Program#get:code - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/typedarray/Uint8Array#toString - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program/Program#get:mask - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program/Mask#toString - local.tee $2 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program/Program#get:jumpTable - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program/JumpTable#toString - local.tee $3 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $assembly/program/Program#get:basicBlocks - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $assembly/program/BasicBlocks#toString - local.tee $4 - i32.store offset=20 - i32.const 26432 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 1 - local.get $1 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26432 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 3 - local.get $2 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26432 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 5 - local.get $3 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26432 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 7 - local.get $4 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26432 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - i32.const 4080 - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store offset=4 - local.get $5 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $5 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $5 - return - ) - (func $"~lib/map/Map#get:size" (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $"~lib/map/Map#get:entriesCount" - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/util/string/joinIntegerArray (param $dataStart i32) (param $length i32) (param $separator i32) (result i32) - (local $lastIndex i32) - (local $value i64) - (local $sepLen i32) - (local $estLen i32) - (local $result i32) - (local $offset i32) - (local $value|9 i64) - (local $i i32) - (local $11 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $length - i32.const 1 - i32.sub - local.set $lastIndex - local.get $lastIndex - i32.const 0 - i32.lt_s - if - i32.const 4080 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $lastIndex - i32.eqz - if - local.get $dataStart - i64.load - local.set $value - i32.const 0 - drop - i32.const 8 - i32.const 4 - i32.le_u - drop - local.get $value - i32.const 10 - call $~lib/util/number/utoa64 - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $separator - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - call $~lib/string/String#get:length - local.set $sepLen - i32.const 20 - local.get $sepLen - i32.add - local.get $lastIndex - i32.mul - i32.const 20 - i32.add - local.set $estLen - global.get $~lib/memory/__stack_pointer - local.get $estLen - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $result - i32.store offset=4 - i32.const 0 - local.set $offset - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $lastIndex - i32.lt_s - if - local.get $dataStart - local.get $i - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $sepLen - if - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $separator - local.get $sepLen - i32.const 1 - i32.shl - memory.copy - local.get $offset - local.get $sepLen - i32.add - local.set $offset - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - local.get $dataStart - local.get $lastIndex - i32.const 3 - i32.shl - i32.add - i64.load - local.set $value|9 - local.get $offset - local.get $result - local.get $offset - i32.const 1 - i32.shl - i32.add - local.get $value|9 - call $~lib/util/number/itoa_buffered - i32.add - local.set $offset - local.get $estLen - local.get $offset - i32.gt_s - if - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - local.get $11 - i32.store - local.get $11 - i32.const 0 - local.get $offset - call $~lib/string/String#substring - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - end - local.get $result - local.set $11 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $11 - return - ) - (func $~lib/staticarray/StaticArray#join (param $this i32) (param $separator i32) (result i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i32.const 0 - drop - i32.const 1 - drop - local.get $this - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store offset=4 - local.get $2 - call $~lib/staticarray/StaticArray#get:length - local.get $separator - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/util/string/joinIntegerArray - local.set $2 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $2 - return - ) - (func $~lib/staticarray/StaticArray#toString (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - i32.const 10000 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - call $~lib/staticarray/StaticArray#join - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $assembly/spi/StandardProgram#toString (param $this i32) (result i32) - (local $1 i32) - (local $2 i32) - (local $3 i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 24 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/spi/StandardProgram#get:program - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $assembly/program/Program#toString - local.tee $1 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=12 - local.get $4 - call $assembly/spi/StandardProgram#get:memory - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/memory/Memory#get:pages - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $"~lib/map/Map#get:size" - i32.const 10 - call $~lib/number/I32#toString - local.tee $2 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $assembly/spi/StandardProgram#get:registers - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - call $~lib/staticarray/StaticArray#toString - local.tee $3 - i32.store offset=20 - i32.const 26160 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 1 - local.get $1 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26160 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 3 - local.get $2 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26160 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 5 - local.get $3 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 26160 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store - local.get $4 - i32.const 4080 - local.set $4 - global.get $~lib/memory/__stack_pointer - local.get $4 - i32.store offset=4 - local.get $4 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 24 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $start:assembly/spi.test~anonymous|0 (param $$0 i32) (result i32) - (local $1 i32) - (local $PROGRAM i32) - (local $3 i32) - (local $ARGS i32) - (local $spi i32) - (local $assert i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 36 - memory.fill - global.get $~lib/memory/__stack_pointer - i32.const 28 - i32.const 0 - i32.const 34 - i32.const 25472 - call $~lib/rt/__newArray - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $assembly/program/liftBytes - local.tee $PROGRAM - i32.store offset=4 - global.get $~lib/memory/__stack_pointer - i32.const 3 - i32.const 0 - i32.const 34 - i32.const 25520 - call $~lib/rt/__newArray - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $assembly/program/liftBytes - local.tee $ARGS - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $PROGRAM - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $ARGS - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - call $assembly/spi/decodeSpi - local.tee $spi - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.tee $assert - i32.store offset=20 - local.get $assert - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - local.get $spi - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=32 - local.get $7 - call $assembly/spi/StandardProgram#toString - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=12 - local.get $7 - i32.const 26496 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=24 - local.get $7 - i32.const 4080 - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store offset=28 - local.get $7 - call $assembly/test/Assert#isEqual<~lib/string/String> - local.get $assert - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 36 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $start:assembly/spi.test - (local $0 i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store offset=8 - call $start:assembly/spi - global.get $~lib/memory/__stack_pointer - i32.const 1 - i32.const 2 - i32.const 23 - i32.const 0 - call $~lib/rt/__newArray - local.tee $0 - i32.store - local.get $0 - i32.const 0 - i32.const 25392 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=4 - local.get $1 - i32.const 26976 - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store offset=8 - local.get $1 - call $assembly/test/test - call $~lib/array/Array#__set - local.get $0 - global.set $assembly/spi.test/TESTS - global.get $~lib/memory/__stack_pointer - i32.const 12 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 21616 - i32.const 1888 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/array/Array<~lib/string/String>#get:length (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - local.get $1 - i32.store - local.get $1 - call $~lib/array/Array<~lib/string/String>#get:length_ - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - return - ) - (func $~lib/array/Array<~lib/string/String>#__get (param $this i32) (param $index i32) (result i32) - (local $value i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - local.get $index - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<~lib/string/String>#get:length_ - i32.ge_u - if - i32.const 480 - i32.const 1888 - i32.const 114 - i32.const 42 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $this - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.get $index - i32.const 2 - i32.shl - i32.add - i32.load - local.tee $value - i32.store offset=4 - i32.const 1 - drop - i32.const 0 - i32.eqz - drop - local.get $value - i32.eqz - if - i32.const 21616 - i32.const 1888 - i32.const 118 - i32.const 40 - call $~lib/builtins/abort - unreachable - end - local.get $value - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $assembly/test-run/printSummary (param $msg i32) (param $okay i32) (param $total i32) - (local $ico i32) - (local $4 i32) - (local $5 i32) - (local $6 i32) - (local $7 i32) - (local $8 i32) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - global.get $~lib/memory/__stack_pointer - local.get $okay - local.get $total - i32.eq - if (result i32) - i32.const 27328 - else - i32.const 27360 - end - local.tee $ico - i32.store - global.get $~lib/memory/__stack_pointer - local.get $msg - local.tee $4 - i32.store offset=8 - global.get $~lib/memory/__stack_pointer - local.get $okay - i32.const 10 - call $~lib/number/U32#toString - local.tee $5 - i32.store offset=12 - global.get $~lib/memory/__stack_pointer - local.get $total - i32.const 10 - call $~lib/number/U32#toString - local.tee $6 - i32.store offset=16 - global.get $~lib/memory/__stack_pointer - local.get $ico - local.tee $7 - i32.store offset=20 - i32.const 27456 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 0 - local.get $4 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27456 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 2 - local.get $5 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27456 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 4 - local.get $6 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27456 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 6 - local.get $7 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27456 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=24 - local.get $8 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=28 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $assembly/test-run/run (param $tests i32) (param $file i32) (result i64) - (local $ok i32) - (local $i i32) - (local $res i32) - (local $5 i32) - (local $j i32) - (local $7 i32) - (local $8 i32) - (local $9 i64) - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 32 - memory.fill - i32.const 0 - local.set $ok - i32.const 27040 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $file - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/console/console.log - i32.const 0 - local.set $i - loop $for-loop|0 - local.get $i - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/array/Array#get:length - i32.lt_s - if - i32.const 27072 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - local.get $i - call $~lib/array/Array#__get - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - call $assembly/test/Test#get:name - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/console/console.log - global.get $~lib/memory/__stack_pointer - i32.const 0 - call $assembly/test/Assert#constructor - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - i32.const 1 - global.set $~argumentsLength - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - local.get $i - call $~lib/array/Array#__get - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/test/Test#get:ptr - i32.load - call_indirect (type $0) - local.tee $res - i32.store offset=20 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $assembly/test/Assert#get:isOkay - if - global.get $~lib/memory/__stack_pointer - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - local.get $i - call $~lib/array/Array#__get - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/test/Test#get:name - local.tee $5 - i32.store offset=24 - i32.const 27168 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 1 - local.get $5 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27168 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/console/console.log - local.get $ok - i32.const 1 - i32.add - local.set $ok - else - i32.const 0 - local.set $j - loop $for-loop|1 - local.get $j - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/test/Assert#get:errors - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/array/Array<~lib/string/String>#get:length - i32.lt_s - if - i32.const 27200 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $res - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=16 - local.get $8 - call $assembly/test/Assert#get:errors - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=12 - local.get $8 - local.get $j - call $~lib/array/Array<~lib/string/String>#__get - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/console/console.log - local.get $j - i32.const 1 - i32.add - local.set $j - br $for-loop|1 - end - end - global.get $~lib/memory/__stack_pointer - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - local.get $i - call $~lib/array/Array#__get - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $assembly/test/Test#get:name - local.tee $7 - i32.store offset=28 - i32.const 27264 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 1 - local.get $7 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#__uset - i32.const 27264 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - i32.const 4080 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/staticarray/StaticArray<~lib/string/String>#join - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/console/console.log - end - local.get $i - i32.const 1 - i32.add - local.set $i - br $for-loop|0 - end - end - i32.const 27296 - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - local.get $file - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=8 - local.get $8 - call $~lib/string/String#concat - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - local.get $ok - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store offset=4 - local.get $8 - call $~lib/array/Array#get:length - call $assembly/test-run/printSummary - local.get $ok - i64.extend_i32_s - i64.const 32 - i64.shl - local.get $tests - local.set $8 - global.get $~lib/memory/__stack_pointer - local.get $8 - i32.store - local.get $8 - call $~lib/array/Array#get:length - i64.extend_i32_s - i64.add - local.set $9 - global.get $~lib/memory/__stack_pointer - i32.const 32 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $9 - return - ) - (func $assembly/test-run/runAllTests - (local $a i64) - (local $okay i32) - (local $total i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i64.const 0 - i64.store - i64.const 0 - local.set $a - local.get $a - global.get $assembly/instructions/bit.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27008 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/instructions/branch.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27504 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/instructions/logic.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27552 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/instructions/math.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27600 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/memory.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27648 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/program.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27696 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/instructions/rot.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27744 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - global.get $assembly/spi.test/TESTS - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - i32.const 27776 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store offset=4 - local.get $3 - call $assembly/test-run/run - i64.add - local.set $a - local.get $a - i64.const 32 - i64.shr_u - i32.wrap_i64 - local.set $okay - local.get $a - i32.wrap_i64 - local.set $total - i32.const 27808 - local.set $3 - global.get $~lib/memory/__stack_pointer - local.get $3 - i32.store - local.get $3 - local.get $okay - local.get $total - call $assembly/test-run/printSummary - local.get $okay - local.get $total - i32.ne - if - i32.const 27856 - i32.const 27920 - i32.const 28 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - i32.const 8 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28~lib/typedarray/Uint8Array%2Cu32%29=>assembly/arguments/Args>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $"~lib/map/Map#__visit" (param $this i32) (param $cookie i32) - (local $entries i32) - (local $cur i32) - (local $end i32) - (local $entry i32) - (local $val i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:buckets" - local.get $cookie - call $~lib/rt/itcms/__visit - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:entries" - local.set $entries - i32.const 1 - drop - local.get $entries - local.set $cur - local.get $cur - local.get $this - local.set $7 - global.get $~lib/memory/__stack_pointer - local.get $7 - i32.store - local.get $7 - call $"~lib/map/Map#get:entriesOffset" - block $"~lib/map/ENTRY_SIZE|inlined.6" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.6" - end - i32.mul - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - local.set $entry - local.get $entry - call $"~lib/map/MapEntry#get:taggedNext" - i32.const 1 - i32.and - i32.eqz - if - i32.const 0 - drop - i32.const 1 - drop - local.get $entry - call $"~lib/map/MapEntry#get:value" - local.set $val - i32.const 0 - drop - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - block $"~lib/map/ENTRY_SIZE|inlined.7" (result i32) - i32.const 12 - br $"~lib/map/ENTRY_SIZE|inlined.7" - end - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $entries - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<~lib/string/String>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<~lib/string/String>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28assembly/test/Assert%29=>assembly/test/Assert>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#__visit (param $this i32) (param $cookie i32) - (local $cur i32) - (local $end i32) - (local $val i32) - (local $5 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 1 - drop - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:dataStart - local.set $cur - local.get $cur - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:length_ - i32.const 2 - i32.shl - i32.add - local.set $end - loop $while-continue|0 - local.get $cur - local.get $end - i32.lt_u - if - local.get $cur - i32.load - local.set $val - local.get $val - if - local.get $val - local.get $cookie - call $~lib/rt/itcms/__visit - end - local.get $cur - i32.const 4 - i32.add - local.set $cur - br $while-continue|0 - end - end - local.get $this - local.set $5 - global.get $~lib/memory/__stack_pointer - local.get $5 - i32.store - local.get $5 - call $~lib/array/Array<%28assembly/arguments/Args%2C~lib/staticarray/StaticArray%2Cassembly/memory/Memory%29=>assembly/instructions/outcome/OutcomeData>#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/function/Function<%28u8%29=>u8>#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/function/Function<%28u8%29=>u8>#get:_env - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/array/Array#__visit (param $this i32) (param $cookie i32) - (local $2 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - i32.const 0 - drop - local.get $this - local.set $2 - global.get $~lib/memory/__stack_pointer - local.get $2 - i32.store - local.get $2 - call $~lib/array/Array#get:buffer - local.get $cookie - call $~lib/rt/itcms/__visit - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - ) - (func $~lib/object/Object#constructor (param $this i32) (result i32) - (local $1 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $this - i32.eqz - if - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.const 0 - call $~lib/rt/itcms/__new - local.tee $this - i32.store - end - local.get $this - local.set $1 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $1 - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 3 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1408 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 3 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 13 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/arraybuffer/ArrayBuffer#constructor (param $this i32) (param $length i32) (result i32) - (local $buffer i32) - (local $3 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.gt_u - if - i32.const 1296 - i32.const 1344 - i32.const 52 - i32.const 43 - call $~lib/builtins/abort - unreachable - end - global.get $~lib/memory/__stack_pointer - local.get $length - i32.const 1 - call $~lib/rt/itcms/__new - local.tee $buffer - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $buffer - local.set $3 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $3 - return - ) - (func $~lib/rt/__newArray (param $length i32) (param $alignLog2 i32) (param $id i32) (param $data i32) (result i32) - (local $bufferSize i32) - (local $buffer i32) - (local $array i32) - (local $7 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - local.get $alignLog2 - i32.shl - local.set $bufferSize - global.get $~lib/memory/__stack_pointer - local.get $bufferSize - i32.const 1 - local.get $data - call $~lib/rt/__newBuffer - local.tee $buffer - i32.store - i32.const 16 - local.get $id - call $~lib/rt/itcms/__new - local.set $array - local.get $array - local.get $buffer - i32.store - local.get $array - local.get $buffer - i32.const 0 - call $~lib/rt/itcms/__link - local.get $array - local.get $buffer - i32.store offset=4 - local.get $array - local.get $bufferSize - i32.store offset=8 - local.get $array - local.get $length - i32.store offset=12 - local.get $array - local.set $7 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $7 - return - ) - (func $~lib/util/number/itoa32 (param $value i32) (param $radix i32) (result i32) - (local $sign i32) - (local $out i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|8 i32) - (local $buffer|9 i32) - (local $num|10 i32) - (local $offset|11 i32) - (local $val32 i32) - (local $decimals|13 i32) - (local $14 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 2304 - i32.const 2432 - i32.const 373 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i32.eqz - if - i32.const 2496 - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - end - local.get $value - i32.const 31 - i32.shr_u - i32.const 1 - i32.shl - local.set $sign - local.get $sign - if - i32.const 0 - local.get $value - i32.sub - local.set $value - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer - local.get $value - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 31 - local.get $value - i32.clz - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|8 - global.get $~lib/memory/__stack_pointer - local.get $decimals|8 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|9 - local.get $value - local.set $num|10 - local.get $decimals|8 - local.set $offset|11 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|9 - local.get $num|10 - i64.extend_i32_u - local.get $offset|11 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.set $val32 - local.get $val32 - i64.extend_i32_u - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|13 - global.get $~lib/memory/__stack_pointer - local.get $decimals|13 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.get $val32 - i64.extend_i32_u - local.get $decimals|13 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $sign - if - local.get $out - i32.const 45 - i32.store16 - end - local.get $out - local.set $14 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $14 - return - ) - (func $~lib/util/number/utoa64 (param $value i64) (param $radix i32) (result i32) - (local $out i32) - (local $val32 i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|8 i32) - (local $buffer|9 i32) - (local $num|10 i64) - (local $offset|11 i32) - (local $decimals|12 i32) - (local $buffer|13 i32) - (local $num|14 i64) - (local $offset|15 i32) - (local $decimals|16 i32) - (local $17 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 2304 - i32.const 2432 - i32.const 401 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i64.const 0 - i64.ne - i32.eqz - if - i32.const 2496 - local.set $17 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $17 - return - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - call $~lib/util/number/decimalCount64High - local.set $decimals|8 - global.get $~lib/memory/__stack_pointer - local.get $decimals|8 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|9 - local.get $value - local.set $num|10 - local.get $decimals|8 - local.set $offset|11 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|9 - local.get $num|10 - local.get $offset|11 - call $~lib/util/number/utoa64_dec_lut - end - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 63 - local.get $value - i64.clz - i32.wrap_i64 - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|12 - global.get $~lib/memory/__stack_pointer - local.get $decimals|12 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|13 - local.get $value - local.set $num|14 - local.get $decimals|12 - local.set $offset|15 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|13 - local.get $num|14 - local.get $offset|15 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|16 - global.get $~lib/memory/__stack_pointer - local.get $decimals|16 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $value - local.get $decimals|16 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $out - local.set $17 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $17 - return - ) - (func $~lib/util/number/itoa64 (param $value i64) (param $radix i32) (result i32) - (local $sign i32) - (local $out i32) - (local $val32 i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|9 i32) - (local $buffer|10 i32) - (local $num|11 i64) - (local $offset|12 i32) - (local $decimals|13 i32) - (local $buffer|14 i32) - (local $num|15 i64) - (local $offset|16 i32) - (local $decimals|17 i32) - (local $18 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 2304 - i32.const 2432 - i32.const 431 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i64.const 0 - i64.ne - i32.eqz - if - i32.const 2496 - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - end - local.get $value - i64.const 63 - i64.shr_u - i32.wrap_i64 - i32.const 1 - i32.shl - local.set $sign - local.get $sign - if - i64.const 0 - local.get $value - i64.sub - local.set $value - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - global.get $~lib/builtins/u32.MAX_VALUE - i64.extend_i32_u - i64.le_u - if - local.get $value - i32.wrap_i64 - local.set $val32 - local.get $val32 - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer - local.get $val32 - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $value - call $~lib/util/number/decimalCount64High - local.set $decimals|9 - global.get $~lib/memory/__stack_pointer - local.get $decimals|9 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|10 - local.get $value - local.set $num|11 - local.get $decimals|9 - local.set $offset|12 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|10 - local.get $num|11 - local.get $offset|12 - call $~lib/util/number/utoa64_dec_lut - end - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 63 - local.get $value - i64.clz - i32.wrap_i64 - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|13 - global.get $~lib/memory/__stack_pointer - local.get $decimals|13 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.set $buffer|14 - local.get $value - local.set $num|15 - local.get $decimals|13 - local.set $offset|16 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|14 - local.get $num|15 - local.get $offset|16 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|17 - global.get $~lib/memory/__stack_pointer - local.get $decimals|17 - i32.const 1 - i32.shl - local.get $sign - i32.add - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $sign - i32.add - local.get $value - local.get $decimals|17 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $sign - if - local.get $out - i32.const 45 - i32.store16 - end - local.get $out - local.set $18 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $18 - return - ) - (func $~lib/util/number/utoa32 (param $value i32) (param $radix i32) (result i32) - (local $out i32) - (local $decimals i32) - (local $buffer i32) - (local $num i32) - (local $offset i32) - (local $decimals|7 i32) - (local $buffer|8 i32) - (local $num|9 i32) - (local $offset|10 i32) - (local $decimals|11 i32) - (local $12 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $radix - i32.const 2 - i32.lt_s - if (result i32) - i32.const 1 - else - local.get $radix - i32.const 36 - i32.gt_s - end - if - i32.const 2304 - i32.const 2432 - i32.const 350 - i32.const 5 - call $~lib/builtins/abort - unreachable - end - local.get $value - i32.eqz - if - i32.const 2496 - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - end - local.get $radix - i32.const 10 - i32.eq - if - local.get $value - call $~lib/util/number/decimalCount32 - local.set $decimals - global.get $~lib/memory/__stack_pointer - local.get $decimals - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer - local.get $value - local.set $num - local.get $decimals - local.set $offset - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer - local.get $num - local.get $offset - call $~lib/util/number/utoa32_dec_lut - else - local.get $radix - i32.const 16 - i32.eq - if - i32.const 31 - local.get $value - i32.clz - i32.sub - i32.const 2 - i32.shr_s - i32.const 1 - i32.add - local.set $decimals|7 - global.get $~lib/memory/__stack_pointer - local.get $decimals|7 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.set $buffer|8 - local.get $value - local.set $num|9 - local.get $decimals|7 - local.set $offset|10 - i32.const 0 - i32.const 1 - i32.ge_s - drop - local.get $buffer|8 - local.get $num|9 - i64.extend_i32_u - local.get $offset|10 - call $~lib/util/number/utoa_hex_lut - else - local.get $value - i64.extend_i32_u - local.get $radix - call $~lib/util/number/ulog_base - local.set $decimals|11 - global.get $~lib/memory/__stack_pointer - local.get $decimals|11 - i32.const 1 - i32.shl - i32.const 2 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - local.get $out - local.get $value - i64.extend_i32_u - local.get $decimals|11 - local.get $radix - call $~lib/util/number/utoa64_any_core - end - end - local.get $out - local.set $12 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $12 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 0 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1408 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 0 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 29 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1408 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 2 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 38 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) - (func $~lib/staticarray/StaticArray#constructor (param $this i32) (param $length i32) (result i32) - (local $outSize i32) - (local $out i32) - (local $4 i32) - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.sub - global.set $~lib/memory/__stack_pointer - call $~stack_check - global.get $~lib/memory/__stack_pointer - i32.const 0 - i32.store - local.get $length - i32.const 1073741820 - i32.const 2 - i32.shr_u - i32.gt_u - if - i32.const 1296 - i32.const 1408 - i32.const 51 - i32.const 60 - call $~lib/builtins/abort - unreachable - end - local.get $length - i32.const 2 - i32.shl - local.set $outSize - global.get $~lib/memory/__stack_pointer - local.get $outSize - i32.const 44 - call $~lib/rt/itcms/__new - local.tee $out - i32.store - i32.const 2 - global.get $~lib/shared/runtime/Runtime.Incremental - i32.ne - drop - local.get $out - local.set $4 - global.get $~lib/memory/__stack_pointer - i32.const 4 - i32.add - global.set $~lib/memory/__stack_pointer - local.get $4 - return - ) -) From 2e19ccf966495403e9a5779f941bc6dbb243cd8b Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Thu, 16 Oct 2025 13:39:26 +0200 Subject: [PATCH 12/21] fixed --- assembly/api-debugger.ts | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/assembly/api-debugger.ts b/assembly/api-debugger.ts index c27e951..1ea1f70 100644 --- a/assembly/api-debugger.ts +++ b/assembly/api-debugger.ts @@ -173,8 +173,9 @@ export function getMemory(address: u32, length: u32): Uint8Array { } const int = interpreter; const result = new Uint8Array(length); - const fault = int.memory.bytesRead(address, result); - if (fault.isFault) { + const faultRes = new MaybePageFault(); + int.memory.bytesRead(faultRes, address, result, 0); + if (faultRes.isFault) { return new Uint8Array(0); } return result; From c641288cdf32930efa0f511f28e4fa0b43fab774 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Thu, 16 Oct 2025 13:50:41 +0200 Subject: [PATCH 13/21] update readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 52a054b..f00a9ea 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # 🍍 anan-as -Assembly Script implementation of the JAM PVM (32bit). +Assembly Script implementation of the JAM PVM (64bit). [Demo](https://todr.me/anan-as) From 42a544665952f6fe01ec6cae3900108314d2c1fa Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Thu, 16 Oct 2025 13:53:50 +0200 Subject: [PATCH 14/21] align readme with convention --- README.md | 35 +++++++++++++++++++---------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index f00a9ea..e22a203 100644 --- a/README.md +++ b/README.md @@ -4,21 +4,20 @@ Assembly Script implementation of the JAM PVM (64bit). [Demo](https://todr.me/anan-as) -#### Todo +## Todo - [x] Memory - [x] [JAM tests](https://github.com/w3f/jamtestvectors/pull/3) compatibility - [x] 64-bit & new instructions ([GrayPaper v0.5.0](https://graypaper.fluffylabs.dev)) - [x] GP 0.5.4 compatibility (ZBB extensions) -### Why? +## Why? - [Pineaples](https://en.wikipedia.org/wiki/Ananas) are cool. - [JAM](https://graypaper.com/) is promising. - [PVM](https://github.com/paritytech/polkavm) is neat. - -### Useful where? +## Useful where? - Potentially as an alternative implementation for [`typeberry`](https://github.com/fluffylabs). - To test out the [PVM debugger](https://pvm.fluffylabs.dev). @@ -54,9 +53,11 @@ ananAs.__collect(); ``` -### Raw Bindings +## Raw Bindings -Raw bindings give you direct access to WebAssembly exports without the JavaScript wrapper layer. This is useful for instantiating multiple instances or when you need more control: +Raw bindings give you direct access to WebAssembly exports +without the JavaScript wrapper layer. +This is useful for instantiating multiple instances or when you need more control: ```javascript // Raw bindings @@ -74,9 +75,10 @@ const ananAs = await instantiate(module); ``` -### Version Tags +## Version Tags -When installing the package, you can choose between stable releases and bleeding-edge builds: +When installing the package, you can choose between stable releases +and bleeding-edge builds: ```bash # Latest stable release @@ -89,24 +91,25 @@ npm install @fluffylabs/anan-as@next ## Building To download the dependencies: -``` -$ npm ci + +```cmd +npm ci ``` To build the WASM modules (in `./build/{release,debug}.wasm`): -``` -$ npm run build +```cmd +npm run build ``` To run the example in the browser at [http://localhost:3000](http://localhost:3000). -``` -$ npm run web +```cmd +npm run web ``` To run JSON test vectors. -``` -$ npm start ./path/to/tests/*.json +```cmd +npm start ./path/to/tests/*.json ``` From 9c9d19c3aa6ad24bd20e9cc84ef70d038d5fd6e8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomek=20Drwi=C4=99ga?= Date: Thu, 16 Oct 2025 17:19:05 +0200 Subject: [PATCH 15/21] Apply suggestion from @coderabbitai[bot] Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e22a203..92b3a6c 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # 🍍 anan-as -Assembly Script implementation of the JAM PVM (64bit). +AssemblyScript implementation of the JAM PVM (64-bit). [Demo](https://todr.me/anan-as) From b0e2b2a0b2a62d8896f867752fc9382744bdbc89 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomek=20Drwi=C4=99ga?= Date: Thu, 16 Oct 2025 17:19:22 +0200 Subject: [PATCH 16/21] Apply suggestion from @coderabbitai[bot] Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 92b3a6c..ce3c145 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ AssemblyScript implementation of the JAM PVM (64-bit). ## Why? -- [Pineaples](https://en.wikipedia.org/wiki/Ananas) are cool. +- [Pineapples](https://en.wikipedia.org/wiki/Ananas) are cool. - [JAM](https://graypaper.com/) is promising. - [PVM](https://github.com/paritytech/polkavm) is neat. From c6842f053f77a2e2e0d55d9f701691ebe3ca6903 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Fri, 17 Oct 2025 10:18:50 +0200 Subject: [PATCH 17/21] freeing memory in runVm --- assembly/api-internal.ts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/assembly/api-internal.ts b/assembly/api-internal.ts index de5056b..3106d0b 100644 --- a/assembly/api-internal.ts +++ b/assembly/api-internal.ts @@ -75,8 +75,10 @@ export function runVm(input: VmInput, logs: boolean = false, useSbrkGas: boolean int.useSbrkGas = useSbrkGas; int.nextPc = input.pc; int.gas.set(input.gas); - - return executeProgram(int, logs); + const result = executeProgram(int, logs); + // release used pages back + int.memory.free(); + return result; } export function getOutputChunks(memory: Memory): InitialChunk[] { From 0f3d3f91b7e2d8222cb2e43aab31986b1c010972 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Thu, 23 Oct 2025 19:45:16 +0200 Subject: [PATCH 18/21] return null and boolean on memory manipulation --- assembly/api-debugger.ts | 13 +++++++------ package-lock.json | 4 ++-- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/assembly/api-debugger.ts b/assembly/api-debugger.ts index 1ea1f70..4279898 100644 --- a/assembly/api-debugger.ts +++ b/assembly/api-debugger.ts @@ -167,23 +167,23 @@ export function getPageDump(index: u32): Uint8Array { return page; } -export function getMemory(address: u32, length: u32): Uint8Array { +export function getMemory(address: u32, length: u32): Uint8Array | null { if (interpreter === null) { - return new Uint8Array(0); + return null; } const int = interpreter; const result = new Uint8Array(length); const faultRes = new MaybePageFault(); int.memory.bytesRead(faultRes, address, result, 0); if (faultRes.isFault) { - return new Uint8Array(0); + return null; } return result; } -export function setMemory(address: u32, data: Uint8Array): void { +export function setMemory(address: u32, data: Uint8Array): boolean { if (interpreter === null) { - return; + return false; } const int = interpreter; const end = address + data.length; @@ -191,9 +191,10 @@ export function setMemory(address: u32, data: Uint8Array): void { for (let i = address; i < end; i++) { int.memory.setU8(faultRes, i, data[i - address]); if (faultRes.isFault) { - throw new Error(`Page fault at ${faultRes.fault} when setting memory.`); + return false; } } + return true; } function fillRegisters(registers: Registers, flat: u8[]): void { diff --git a/package-lock.json b/package-lock.json index bd0b7c7..022483a 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,11 +1,11 @@ { - "name": "anan-as", + "name": "@fluffylabs/anan-as", "version": "1.0.0", "lockfileVersion": 3, "requires": true, "packages": { "": { - "name": "anan-as", + "name": "@fluffylabs/anan-as", "version": "1.0.0", "license": "MPL-2.0", "dependencies": { From ec6b1a0e13ee5c652a5cadb6ed72e2e7c615a905 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marcin=20Soko=C5=82owski?= Date: Sat, 25 Oct 2025 17:41:43 +0200 Subject: [PATCH 19/21] Update assembly/api-debugger.ts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Tomek Drwięga --- assembly/api-debugger.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/assembly/api-debugger.ts b/assembly/api-debugger.ts index 4279898..ffb67ec 100644 --- a/assembly/api-debugger.ts +++ b/assembly/api-debugger.ts @@ -167,6 +167,11 @@ export function getPageDump(index: u32): Uint8Array { return page; } +/** + * Read a chunk of memory at `[address, address + length)`. + * + * Returns the requested memory chunk or `null` if reading triggered a page fault. + */ export function getMemory(address: u32, length: u32): Uint8Array | null { if (interpreter === null) { return null; From 0445a712e8be85e1df92dccce83b9bdf7eccf811 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marcin=20Soko=C5=82owski?= Date: Sat, 25 Oct 2025 17:42:01 +0200 Subject: [PATCH 20/21] Update assembly/api-debugger.ts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Tomek Drwięga --- assembly/api-debugger.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/assembly/api-debugger.ts b/assembly/api-debugger.ts index ffb67ec..ccb4730 100644 --- a/assembly/api-debugger.ts +++ b/assembly/api-debugger.ts @@ -186,6 +186,11 @@ export function getMemory(address: u32, length: u32): Uint8Array | null { return result; } +/** + * Write given `data` under memory indices `[address, address + data.length)`. + * + * Returns `true` if the write was successful and `false` if page fault has been triggered. + */ export function setMemory(address: u32, data: Uint8Array): boolean { if (interpreter === null) { return false; From 6467c05de367d2ace05d74371037e3b69f517784 Mon Sep 17 00:00:00 2001 From: HeyImStas Date: Sat, 25 Oct 2025 17:44:16 +0200 Subject: [PATCH 21/21] qa-fix --- assembly/api-debugger.ts | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/assembly/api-debugger.ts b/assembly/api-debugger.ts index ccb4730..33ab249 100644 --- a/assembly/api-debugger.ts +++ b/assembly/api-debugger.ts @@ -167,11 +167,11 @@ export function getPageDump(index: u32): Uint8Array { return page; } -/** - * Read a chunk of memory at `[address, address + length)`. - * - * Returns the requested memory chunk or `null` if reading triggered a page fault. - */ +/** + * Read a chunk of memory at `[address, address + length)`. + * + * Returns the requested memory chunk or `null` if reading triggered a page fault. + */ export function getMemory(address: u32, length: u32): Uint8Array | null { if (interpreter === null) { return null; @@ -188,9 +188,9 @@ export function getMemory(address: u32, length: u32): Uint8Array | null { /** * Write given `data` under memory indices `[address, address + data.length)`. - * + * * Returns `true` if the write was successful and `false` if page fault has been triggered. - */ + */ export function setMemory(address: u32, data: Uint8Array): boolean { if (interpreter === null) { return false;